Paste Style Guide¶

Generally you should follow the recommendations in PEP 8, the Python Style Guide. Some things to take particular note of:

No tabs. Not anywhere. Always indent with 4 spaces.
I don’t stress too much on line length. But try to break lines up by grouping with parenthesis instead of with backslashes (if you can). Do asserts like:
```
assert some_condition(a, b), (
    "Some condition failed, %r isn't right!" % a)
```
But if you are having problems with line length, maybe you should just break the expression up into multiple statements.
Blank lines between methods, unless they are very small and closely bound to each other.
Don’t use the form condition and trueValue or falseValue. Break it out and use a variable.
I (Ian Bicking) am very picky about whitespace. There’s one and only one right way to do it. Good examples:
```
short = 3
longerVar = 4

if x == 4:
    do stuff

func(arg1='a', arg2='b')
func((a + b)*10)
```
Bad examples:
```
short    =3
longerVar=4

if x==4: do stuff

func(arg1 = 'a', arg2 = 'b')
func(a,b)
func( a, b )
[ 1, 2, 3 ]
```
If the whitespace isn’t right, it’ll annoy me and I’ll feel a need to fix it. Really, this whitespace stuff shouldn’t be that controversial should it? Some particular points that I feel strongly about:
- No space after a function name (bad: func (arg)).
- No space after or before a parenthesis (bad: func( arg )).
- Always one space after a comma (bad: func(a,b)).
Use @@ to mark something that is suboptimal, or where you have a concern that it’s not right. Try to also date it and put your username there.
Docstrings are good. They should look like:
```
class AClass(object):
    """
    doc string...
    """
```
Don’t use single quotes (‘’’) – they tend to cause problems in Emacs. Don’t bother trying make the string less vertically compact.
Comments go right before the thing they are commenting on.
Methods never, ever, ever start with capital letters. Generally only classes are capitalized. But definitely never methods.
Use cls to refer to a class. Use meta to refer to a metaclass (which also happens to be a class, but calling a metaclass cls will be confusing).

Use isinstance instead of comparing types. E.g.:

if isinstance(var, str): ...
# Bad:
if type(var) is StringType: ...

Never, ever use two leading underscores. This is annoyingly private. If name clashes are a concern, use explicit name mangling instead (e.g., _MyThing_blahblah). This is essentially the same thing as double-underscore, only it’s transparent where double underscore obscures.
Module names should be unique in the package. Subpackages shouldn’t share module names with sibling or parent packages. Sadly this isn’t possible for __init__.py, but it’s otherwise easy enough.
Module names should be all lower case, and probably have no underscores (smushedwords).