Python Code

Readability is At The Heart of Python Design.

---

• Simple is Better Than Complex...
• Short is Better Than Long...
• Explict is Better Than Implicit...
• Beautiful is Better Than Ugly...
• Readability Counts...

Naming Conventions

Variables, functions, methods, packages, modules :

lower_case_with_underscores

Classes and Exceptions :

CapWords

Private methods :

_single_leading_underscore(self, ...)

Constants :

ALL_CAPS_WITH_UNDERSCORES

Avoid one-letter variables :

l, O, I

Avoid Redundant Labeling

Yes

import audio

core = audio.Core()
controller = audio.Controller()

No

import audio

core = audio.AudioCore()
controller = audio.AudioController()

Prefer "Reverse Notation"

Yes

elements = ...
elements_active = ...
elements_defunct = ...

No

elements = ...
active_elements = ...
defunct_elements ...

Line Length : Don't Stress Over 80-100 Characters

# Use parentheses for line continuations.
wiki = (
    "The Colt Python is a .357 Magnum caliber revolver formerly "
    "manufactured by Colt's Manufacturing Company of Hartford, "
    "Connecticut. It is sometimes referred to as a Combat Magnum "
    "same year as Smith & Wesson's M29 .44 Magnum."
)

Google Comment Style - Function

def func(arg1, arg2, arg3=None):
    """ Intro line

    Rant on here. Make sure it's at least 3-line long (j/k)

    Args:
        arg1: An argument
        arg2: Another argument
        arg3: optional argument

    Returns:
        Describe returned value(s) here

    Raises:
        Error
    """
    pass

Google Comment Style - Class

class SampleClass(object):
    """ Summary of class here.

    Longer class information....
    Longer class information....

    Attributes:
        likes_spam: A boolean indicating if we like SPAM or not.
        eggs: An integer count of the eggs we have laid.
    """

    def __init__(self, likes_spam=False):
        """Inits SampleClass with blah."""
        self.likes_spam = likes_spam
        self.eggs = 0

    def public_method(self):
        """Performs operation blah."""

Dictionary For Performance

What are the difference between two algorithms ?

data_list = [...]                       # len = 500, 000 
interesting_points = [...]              # len =      100

for i in interesting_ids:
    point = find_point_by_id_in_list(data_list, i)
    interesting_points.append(point)

data_lookup = {...}                     # len = 500, 000 
interesting_points = [...]              # len =      100

for i in interesting_ids:
    point = data_lookup(data_list, i)
    interesting_points.append(point)

Memory Efficiency with Slots

Custom types store their data in individualized, dynamic dictionaries via self.__dict__. Using __slots__ to limit available attribute names and move the name/key storage outside the instance to a type level can significantly improve memory usage.

class ImmutableThing:
            
    __slots__ = ['a', 'b', 'c']

    def __init__(self, a, b, c):
         self.a = a 
         self.b = b
         self.c = c

Bisect for Quick Search

Bisect provides support for maintaining a list in sorted order without having to sort the list after each insertion.

import bisect
import random

# Reset the seed
random.seed(1)

# Use bisect_left and insort_left.
l = []
for i in range(1, 5):
    r = random.randint(1, 100)
    position = bisect.bisect_left(l, r)
    bisect.insort_left(l, r)
    print '%2d %2d' % (r, position), l

$ python bisect_example.py

14  0 [14]
85  1 [14, 85]
77  1 [14, 77, 85]
26  1 [14, 26, 77, 85]
50  2 [14, 26, 50, 77, 85]

Pickle For Fast Object Serialization

import pickle

a = A_VERY_LARGE_OBJECT

with open('filename.pickle', 'wb') as handle:
    pickle.dump(a, handle, protocol=pickle.HIGHEST_PROTOCOL)

with open('filename.pickle', 'rb') as handle:
    b = pickle.load(handle)

print(a == b)

Array Serialization

from array import array
from random import random
floats = array('d', (random() for i in range(10**7))) 

fp = open('floats.bin', 'wb')
floats.tofile(fp)
fp.close()

floats2 = array('d') 
fp = open('floats.bin', 'rb') 
floats2.fromfile(fp, 10**7) 
fp.close()

You Might Have Used Decorators
Even Without Knowing It

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

Decorator is Used To Modify The Inner Function

The Following Three Codes Have The Same Effect.

# State, before defining f, that a_decorator will be applied to it.
@a_decorator
def f(...):
    ...

def f(...):
    ...

# After defining f, apply a_decorator to it.
f = a_decorator(f)

def a_decorator():
    ...
    def f(...):
        ...
    ...
    return f

Print Decorated Function's Input Output

def deco(func):
    def inner(*args):
        print('Input :', args)
        output = func(*args)
        print('Output:', output)
        return output
    return inner

@deco
def add(a, b):
    return a + b

>>> add(1, 2)
Input : (1, 2)
Output: 3

Example 1 - Use Decorator to Auto Register
Input, Output and Execution Time

import time

def timer(func):
   
    def clock(*args):
        t0 = time.perf_counter()
        result = func(*args)
        elapsed = time.perf_counter() - t0
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result)) 
        return result
        
    return clock

Example 1 - Use Decorator to Auto Register
Input, Output and Execution Time

import time
from timer import timer

@timer
def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)

if __name__=='__main__':
    factorial(4)

$ python3 clockdeco_demo.py
              
[0.00000191s] factorial(1) -> 1
[0.00004911s] factorial(2) -> 2
[0.00008488s] factorial(3) -> 6
[0.00013208s] factorial(4) -> 24

Example 2 - Use Decorator to Make Class Singleton

class Singleton:

    _singletons = dict()

    def __init__(self, decorated):
        self._decorated = decorated

    def getInstance(self):
        key = self._decorated.__name__
        try:
            return Singleton._singletons[key]
        except KeyError:
            Singleton._singletons[key] = self._decorated()
            return Singleton._singletons[key]

    def __call__(self):
        raise Exception(
            'Singletons must be accessed through the `getInstance` method.')

Example 2 - Use Decorator to Make Class Singleton

@Singleton
class Foo:
    def __init__(self):
        print('Foo created')

    def bar(self, obj):
        print(obj)

foo = Foo()                  # Wrong, raises Exception

foo = Foo.getInstance()
goo = Foo.getInstance()

print(goo is foo)            # True

foo.bar('Hello, world! I m a singleton.')

Python Meta Class Functions

Name	Description
__new__	The real function to create an object.
__init__	Initialize newly created object.
__call__	Make the class callable like a function.

Python Meta Class Functions

class Foo:
            
    def __new__(cls, *args, **kwargs):
        print('Calling __new__')
        return super(Foo, cls).__new__(cls)

    def __init__(self, a):
        print('Calling __init__')
        self.a = a

    def __call__(self, *args, **kwargs):
        print('Calling __call__')
        print(self.a)

>>> f = Foo(1)
Calling __new__
Calling __init__
>>> f()
Calling __call__
1

Example I : __len__ & __getitem__ (1)

import collections
            
Card = collections.namedtuple('Card', ['rank', 'suit'])
 
class FrenchDeck:

    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()
    
    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits
                                        for rank in self.ranks]
        
    def __len__(self):
        return len(self._cards)
        
    def __getitem__(self, position):
        return self._cards[position]

Example I : __len__ & __getitem__ (2)

 >>> deck = FrenchDeck()
 >>> len(deck)
 52

 >>> deck[0]
 Card(rank='2', suit='spades')
 >>> deck[-1]
 Card(rank='A', suit='hearts')

 >>> from random import choice
 >>> choice(deck)
 Card(rank='3', suit='hearts')
 >>> choice(deck)
 Card(rank='K', suit='spades')
 >>> choice(deck)
 Card(rank='2', suit='clubs')

Example I : __len__ & __getitem__ (3)

 >>> deck[:3]
 [Card(rank='2', suit='spades'), Card(rank='3', suit='spades'),
 Card(rank='4', suit='spades')]
 >>> deck[12::13]
 [Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'),
 Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]

 >>> for card in deck: 
 ...   print(card)
 Card(rank='2', suit='spades')
 Card(rank='3', suit='spades')
 Card(rank='4', suit='spades')
 ...

 >>> for card in reversed(deck): 
 ...   print(card)
 Card(rank='A', suit='hearts')
 Card(rank='K', suit='hearts')
 Card(rank='Q', suit='hearts')
 ...

Example II : __iter__

class Article:
    def __init__(self, sentences):
         self.sentences = sentences
    
    def __iter__(self):
         return (sentence for sentence in self.sentences)
         
class Sentence:
    def __init__(self, words):
         self.words = words
    
    def __iter__(self):
         return (word for word in self.words)
         
...

>>> for sentence in article:
>>> ... for word in sentence:
>>> ....... print(word)

Example III : __repr__

from array import array
import math

class Vector2d:
    def __init__(self, x, y):
        self.x = float(x)
        self.y = float(y)

    def __iter__(self):
        return (i for i in (self.x, self.y))

    def __repr__(self):
        class_name = type(self).__name__
        return '{}({!r}, {!r})'.format(class_name, *self)

...
 
>>> v = Vector2d(1, 2)
>>> print(v) 
Vector2d(1.0, 2.0)