Python – Does it make sense to use string constants in Python instead of string literals as keys

programming practicespython

There is a dictionary in my class with informative, short string constants as keys that identify certain parts of the solution, like "velocity", "death_star_power_output". My colleague suggested that I use VELOCITY="velocity" and DEATH_STAR_POWER_OUTPUT="death_star_power_output" to index into this dictionary throughout the program, because it's the practice.

While I know such practices from other programming languages, where they serve a pragmatic purpose – that is to fail-fast in case of misspelling of the string – in Python it's the same one way or the other. Both:

value = dictionary["death_star_powder_output"]

and

DEATH_STAR_POWER_OUTPUT="death_star_power_output"
[...]
value = dictionary[DEATH_STAR_POWDER_OUTPUT]

will fail at the same time. Please notice the misspelling of POWER as POWDER. Is there some official guideline pertaining to this kind of practice in Python?

Best Answer

It's not as useful to eschew string literals in Python as it is in other languages, because Python enforces no strict predeclaration of identifiers, but it is still useful.

It's true that if you misspell a constant name in Python, you might not get a warning until run-time. But sufficiently clever analysers can still detect that you are using a variable that doesn't seem to have a declaration, or that you are declaring a constant that doesn't seem to be used. And since tooling support can only become smarter over time, and tool support changes much faster than language standard, it pays to obey conventions that enable better error checking whether it's already there or not.

Related Solutions

Python Calling Conventions – Argument Passing Mechanism and Official Documentation

In terms of official documentation, per the Programming FAQ:

Remember that arguments are passed by assignment in Python.

Elsewhere in the docs:

The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value (where the value is always an object reference, not the value of the object).

where the footnote adds:

Actually, call by object reference would be a better description, since if a mutable object is passed, the caller will see any changes the callee makes to it (items inserted into a list).

This is consistent with the rest of Python's assignment model, for example:

def somefunc(y):
    y.append(1)

x = [0]
somefunc(x)
print x

is similar to:

x = [0]
y = x
y.append(1)
print x

in that the object assigned to the name x is also assigned to the name y (albeit only within somefunc in the former).

Python Iterators – Why Python Only Copies Individual Elements When Iterating a List

I already answered a similar question lately and it's very important to realize that += can have different meanings:

If the data type implements in-place addition (i.e. has a correctly working __iadd__ function) then the data that i refers to is updated (doesn't matter if it's in a list or somewhere else).
If the data type doesn't implement an __iadd__ method the i += x statement is just syntactic sugar for i = i + x, so a new value is created and assigned to the variable name i.
If the data type implements __iadd__ but it does something weird. It could be possible that it's updated ... or not - that depends on what is implemented there.

Pythons integers, floats, strings don't implement __iadd__ so these will not be updated in-place. However other data types like numpy.array or lists implement it and will behave like you expected. So it's not a matter of copy or no-copy when iterating (normally it doesn't do copies for lists and tuples - but that as well depends on the implementation of the containers __iter__ and __getitem__ method!) - it's more a matter of the data type you have stored in your a.

Best Answer

Related Solutions

Python Calling Conventions – Argument Passing Mechanism and Official Documentation

Python Iterators – Why Python Only Copies Individual Elements When Iterating a List

Related Topic