I find myself needing to get file creation or modification times a lot. This is pretty trivial with using Python’s built in os.stat function. The problem is that it returns the file modification time in seconds since the epoch, which is not exactly the friendliest format to read. Here is an example:

>>> import os
>>> file = "H:\SSDC\common_functions\common_functions.py"
>>> modTime = os.stat(file).st_mtime
>>> print modTime
1334325015.57

Now more power to you if you can look at that and get the date out of there, but I prefer a little more standard notation.

Luckily, this is doable. We need to first convert the epoch seconds that os.stat returned into a time_struct and then we can print that time_struct in a more readable manner.

Here is an example using the same file above:

>>> import time
>>> modTime2 = time.gmtime(os.stat(file).st_mtime)
>>> print modTime2
time.struct_time(tm_year=2012, tm_mon=4, tm_mday=13, tm_hour=13, tm_min=50, tm_sec=15, tm_wday=4, tm_yday=104, tm_isdst=0)
>>> modTime2_hr = time.strftime("%m/%d/%Y %H:%M:%S", modTime2)
>>> print modTime2_hr
04/13/2012 13:50:15

References:
Python Standard Library – os.stat
Python Standard Library – time module

Recently found myself needing to read in a file 4 lines at a time. The solution to this problem turned out to nicely illustrate a concept that I’d read about but never really understood – generators. Let’s take a look at the problem:

Say we have some data in a file like this:

entry1:name
entry1:description
entry1:reference_number
---
entry2:name
entry2:description
entry2:reference_number
---
entry3:name
entry3:description
entry3:reference_number
---

So the easiest way to deal with this would be to read it in 4 lines at a time and deal with each entry as a unique entity with 3 attributes.

Now we could just read in until we hit a record separator (‘—’) but using generators we can have a much more general purpose solution.

First we’ll need to define our generator:

def chunks(l, n):
    #Generator to yield n sized chunks from l
    for i in xrange(0, len(l), n):
        yield l[i: i + n]

What this little bit of code does is return an iterator object that iterates over our list object ‘l’ (in this case a file) and returns ‘n’ chunks from it at a time.

We’d use it to read our example like so:

items = []
fileContents = open(file, 'r').readlines()
for entry in chunks(fileContents, 4):
    items.append(entry[0], entry[1], entry[2])

What we did here is to first read our file into memory as one big list separated by newlines. We then used our generator to return the file in 4 line blocks and shoved the relevant information (ie everything beside the record separator) into a list called items. Now we have a list where each item is a tuple of name, description and reference_number.

Hopefully this helps clear up generators and provides a concrete usage for them.

Link to the Stack Overflow answer that gave me the generator code: http://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks-in-python/312464#312464

I’ve been working to clean up some utility functions that I use a lot and one thing that I do is check for string to see if it is a valid IP v4 address. I have a simple function for this which is by no means exhaustive, but it covers my needs most of the time:

def isIP(address):
    #Takes a string and returns a status if it matches
    #a ipv4 address
    # 0 = false / 1 = true
    ip = False
    try:
        if address[0].isdigit():
            octets = address.split('.')
            if len(octets) == 4:
                ipAddr = "".join(octets)
                if ipAddr.isdigit():
                #correct format
                    if (int(octets[0]) >= 0) and (int(octets[0]) <= 255):
                        if (int(octets[1]) >= 0) and (int(octets[1]) <= 255):
                            if (int(octets[2]) >= 0) and (int(octets[2]) <= 255):
                                if (int(octets[3]) >= 0) and (int(octets[3]) <= 255):
                                    ip = True
    except IndexError:
        pass
    return ip

As you can see, it just takes a string and checks if it meets the form of X.X.X.X and then checks to see if the values fall in the legal (0-255) range and returns True or False. As I said, by no means a complete check on the IPv4 spec, but it covered my needs.

Just out of curiosity, I also wrote up a function to do the same check except using the socket library in Python:

import socket

def isIP_v2(address):
    try:
        socket.inet_aton(address)
        ip = True
    except socket.error:
        ip = False

    return ip

I then wrote up a quick script to check how fast each one was. I assumed mine would be faster since I am doing a simpler check, but wanted to see by how much. I ran it against a list of IP address and non IP address (41,715 real IPs, 10,905 bad addresses) and I was pretty surprised by the results:

PS H:\SSDC\common_functions> C:\Python27\python.exe .\ip_checker.py
Custom Function
Found 41715 Good IPs
Found 10905 Bad IPs
Time: 0.318000078201
Socket Function
Found 41715 Good IPs
Found 10905 Bad IPs
Time: 0.069000005722
PS H:\SSDC\common_functions> C:\Python27\python.exe .\ip_checker.py
Custom Function
Found 41715 Good IPs
Found 10905 Bad IPs
Time: 0.31299996376
Socket Function
Found 41715 Good IPs
Found 10905 Bad IPs
Time: 0.069000005722
PS H:\SSDC\common_functions> C:\Python27\python.exe .\ip_checker.py
Custom Function
Found 41715 Good IPs
Found 10905 Bad IPs
Time: 0.311000108719
Socket Function
Found 41715 Good IPs
Found 10905 Bad IPs
Time: 0.0700001716614

You can see from this (admittedly non-scientific) test that the built in socket test was more then 4 times faster in each test!

So not only is the built in socket function much easier to read, it is significatly faster! I guess it goes back to the old adage, Use built in functions whenever possible.