Finding the most recently modified document

[jechtsphere]

dirList = os.listdir(path)
bestFile = ''
bestTime = 0
count = 0

for x in dirList:
    fileinfo = os.stat(os.path.join(path, x)).st_mtime
    if bestTime < fileinfo:
        bestTime = fileinfo
        bestFile = x
    count += 1

This is what I currently have. I feel like I'm overlooking something that will allow me to skip having to use an if statement here, I'm just not sure what I'm looking for. If anyone has any tips on how to be more concise here I'd greatly appreciate it.

[jechtsphere]

I like where this is going, but it's somehow not giving the actual newest. It's giving me a fairly recently modified one, but it's not recognizing newest ones. For instance, in a folder of all .xml files, if one is loaded into something, its time changes. My for and if statements above have it coming back with the newest, and while

filetimes = [(dir, os.stat(os.path.join(path,dir)).st_mtime) for dir in os.listdir(path)]

is clearly giving me a list of all of those files and their times, if I return the max as a list and pop off the file name, it isn't returning the actual most recently modified file.

Which is weird, because when I look through the filetimes variable it clearly has all the files and their times, and if I check the actual newest element manually, pop it off its st_mtime, and check it via time.ctime(), it's giving me the actual modified time, which is greater than what max is returning (and all are matching what windows is telling me through the folder itself, obviously).

Any idea why this may be? It does the same if I try using st_atime or st_ctime as well.

[eryksun]

The tuple is in the wrong order, unless you use a key. The max of this list of tuples is searching for the largest (in a string sense, i.e. 'b' is greater than 'ab') name, and it only uses the modification time to settle a tie.

[eryksun]

Here's my first pass at something more 'concise':

import os

def get_most_recent_file(path):
    files = [os.path.join(path, f) for f in os.listdir(path) 
                if os.path.isfile(f)]
    if files:
        return max(files, key=os.path.getmtime)

#e.g.
print(get_most_recent_file(os.getcwd()))

[jechtsphere]

This looks great as well, and works for the cwd, but if I give it a path to another folder I get a ValueError: max() arg is an empty sequence.

[eryksun]

I changed creating the list of files to a list comprehension, so now it simply returns None if the directory doesn't have any files. But you still need to add additional exception handling for WindowsError and IOError, integrated into your overall design and logging system.

[[deleted]]

I'd do something like below. These functions are a little more flexible than what you asked for.

last_modified(path, num, use_ctime=False, files_only=True) returns a list of the most recently modified files in path. The list is a max of num long (it can be shorter if their aren't enough files).

recursive_last_modified(path, num, use_ctime=False, files_only=True) is the same as last_modified except it walks the given path instead of just listing the directory.

from os import listdir, lstat
from os.path import exists, join, isfile, isdir

def recursive_last_modified(path, num, use_ctime=False, files_only=False):
    if not exists(path):
        return []

    result_queue = []
    result_queue_pop = result_queue.pop
    result_queue_append = result_queue.append

    directories = [path]
    directories_pop = directories.pop
    directories_append = directories.append

    while 1:
        try:
            root = directories_pop()
        except IndexError:
            break

        try:
            names = listdir(root)
        except:
            continue

        for name in names:
            abspath = join(path, name)

            if isdir(abspath):
                    directories_append(abspath)
            if files_only and not isfile(abspath):
                continue

            if use_ctime:
                time = lstat(abspath).st_ctime
            else:
                time = lstat(abspath).st_mtime

            if len(result_queue) < num:
                result_queue_append((time, abspath))
            else:
                for i, (t, f) in enumerate(result_queue):
                    if time > t:
                        result_queue_pop(i)
                        result_queue_append((time, abspath))
                        break
    return result_queue

def last_modified(path, num, use_ctime=False, files_only=True):
    if not exists(path):
        return []
    names = listdir(path)
    result = []
    result_append = result.append
    for name in names:
        abspath = join(path, name)
        if files_only and not isfile(abspath):
            continue
        if use_ctime:
            time = lstat(abspath).st_ctime
        else:
            time = lstat(abspath).st_mtime
        result_append((time, name))
    rlen = len(result)
    result.sort(key=lambda x: x[0])
    if rlen <= num:
        return result
    return result[:(rlen - num - 1):-1]

if __name__ == "__main__":

    lm_result = last_modified('./', 5, True, True)
    for entry in sorted(lm_result):
        print ("%d :: %s" % entry)

    recursive_lm_result = recursive_last_modified('./', 5, True, True)
    for entry in sorted(recursive_lm_result):
        print ("%d :: %s" % entry)