Python list comprehension on single-valued returns vs nesting

Question

I have a collection of dictionaries declared as class variables (and stored in FILE_TYPES) that define filetypes. I need to cycle through these dictionaries to pair filetype names (stored in the 'name' key) with filenames that are passed into the class. Which of the following ways to do this is more pythonic? Or, is there a better way altogether -- maybe some dict comprehension I'm missing?

First way:

filetype = [ftype for ftype in cls.FILE_TYPES if ftype['name'] in filename][0]

Second way:

for ftype in cls.FILE_TYPES:
    if ftype['name'] in filename:
        filetype = ftype

I am not stuck on this per se, but I'd like to know if either of these approaches is better (e.g., more or less pythonic), or if it makes no difference to anyone.

I generally try to avoid nested logic like you see in the second approach whenever possible if I'm coding in python (not sure why entirely, but at some point this habit was hammered into me by god-knows-who). However, accessing the invariably singular list element in the first method with [0] also seems obnoxious.

Answer 1

I would do with the comprehension-generator inside next() instead of the list comprehension, e.g.:

filetype = next(ftype for ftype in cls.FILE_TYPES if ftype['name'] in filename)

the fundamental difference is that the list comprehension will not take advantage of the fact that you can terminate the loop as soon as the condition is met (so it will be less computationally efficient) and it will create an unnecessary temporary list (so it will be less memory efficient too).

To test it:

file_types = [dict(name='foo'), dict(name='bar'), dict(name='baz'), dict(name='pam'), dict(name='egg'),]
filename = 'spam'

filetype1 = next(ftype for ftype in file_types if ftype['name'] in filename)
print(filetype)
# {'name': 'pam'}

filetype = [ftype for ftype in file_types if ftype['name'] in filename][0]
print(filetype)
# {'name': 'pam'}

for ftype in file_types:
    if ftype['name'] in filename:
        filetype = ftype
        break
print(filetype)
# {'name': 'pam'}

---

EDIT: As per @pault comment this answer is fundamentally the same approach proposed here.

Answer 2

Here is a potentially useful different approach to the problem.

If the filetype is determined by the extension of the file, then the os.path.splitext function can be used to separate the extension from the rest of the filename. Then, the dictionary of filetypes can be a mapping of extensions to whatever filetype object you need.

import os

# as a function/method
def get_filetype(filename):
    ext = os.path.splitext(filename)[1]
    return FILETYPES[ext]

filetype = get_filetype(filename)


# or the one-liner
filetype = FILETYPES[os.path.splitext(filename)[1]]

The upshot is that it runs in constant time with regard to the number of possible extensions. (As long as they are available in the FILETYPES dict.)

This approach also works if you don't use the extensions to figure out the filetype so long as there is some part of the filename that can be extracted and mapped to the filetype. The only change needed would be to change the code that extracts the extension to code that extracts whatever part of the filename determines the filetype.

Answer 3

I would prefer using next, which would raise an exception if no match exists:

filename = "foofoo"
filename2 = "nope"
FILE_TYPES = [{'name':'foo'},{'name':'baz'},{'name':'bat'},{'name':'bar'}]

try:
    print (next(x for x in FILE_TYPES if x['name'] in filename))
    print (next(x for x in FILE_TYPES if x['name'] in filename2))

except StopIteration:
    print ("no such element")

{'name': 'foo'}
no such element