Question

If I understood correctly, it’s better not to use an expression for a local variable that’s already a global function in Python. So I believe this

list = [1,2,3]

is disrecommended in favor of

mylist = [1,2,3]

because list is already a built-in object in Python and mylist is not. However, I’m not always sure whether I should or should not use some expression (e.g. dir, num or cnt). Is there any comprehensive overview of the strings I’d better avoid for naming local variables?

Answer 1

The names to avoid are keywords (which will give you an error, so are easy to spot) and builtins, which will get silently masked. Here’s a snippet of code to test for bad names:

from keyword import kwlist

def bad_name(name):
    return name in dir(__builtins__) + kwlist

… and here’s a list (for Python 3.3):

Builtin functions, types etc.

abs                 all                 any                 ascii
bin                 bool                bytearray           bytes
callable            chr                 classmethod         compile
complex             copyright           credits             delattr
dict                dir                 divmod              enumerate
eval                exec                exit                filter
float               format              frozenset           getattr
globals             hasattr             hash                help
hex                 id                  input               int
isinstance          issubclass          iter                len
license             list                locals              map
max                 memoryview          min                 next
object              oct                 open                ord
pow                 print               property            quit
range               repr                reversed            round
set                 setattr             slice               sorted
staticmethod        str                 sum                 super
tuple               type                vars                zip

Anything in CamelCase (like the builtin exceptions) or beginning with a double underscore is excluded from the list above, as you shouldn’t be using those anyway.

Keywords

False               None                True                and
as                  assert              break               class
continue            def                 del                 elif
else                except              finally             for
from                global              if                  import
in                  is                  lambda              nonlocal
not                 or                  pass                raise
return              try                 while               with
yield