A tour of Python

OVERVIEW• Introduction
• Syntax
• Types and objects
• Operators and expressions
• Structure and control ﬂow
• Functions and functional programming
• Classes and OOP
• Modules, packages, and distribution
• Input and output
• Execution environment
• Testing, debugging, proﬁling and tuning

PYTHON INTERPRETER
PythonCPython
Jython
Python for .NET
IronPython
PyPy
Python is deﬁned “by
implementation”. CPython is
default Python.
CPython is a bytecode interpreter.
It has a foreign function interface
with several languages including C,
in which one must explicitly write
bindings in a language other than
Python.

DATA MODEL
Type hierarchy
None
NotImplemented
Ellipsis
Numbers
numbers.Integral
Plain integers
Long integers
Booleans
numbers.Real
numbers.Complex
Sequences
Immutable
Mutable
Strings
Unicode
Tuples
Lists
Byte arrays
Sets
Mutable
Immutable
Set
Frozen setMappingsDictionaries
Callable
User deﬁned functions
User deﬁned methods
Generator functions
Built-in functions
Built-in methods
Class types
Classic classes
Class instances
Modules
ClassesClass instances
Files
Internal types
Code objects
Frame objects
Traceback objects
Slice objects
Static method objects
Class method objects

OPERATIONS
Operations
Numeric
Integer
int
Boolean subtype
32 bits+
Unlimited precision long
Operations
x | y
x ^ y
x & y
x << n
x >> n
~x
x + y
x - y
x * y
x // y
x % y
-x
+x
abs(x)
int(x)
long(x)
complex(re, im)
z.conjugate()
divmod(x, y)
power
pow(x, y)
x ** y
complex
z.real
z.imag
Additional methods
numbers.Real
math.trunc()
round(x[, n])
math.floor(x)
math.ceil(x)
For floats only
float.as_integer_ratio()
float.is_integer()
float.hex()
float.fromhex()
numbers.Integral
int.bit_length()
long.bit_length()
Sequence
x in s
x not in s
s + t
s * n, n * s
s[i]
s[i:j]
s[i:j:k]
len(s)
min(s)
max(s)
s.index(i)
s.count(i)

COMPARISONS
Truth value testing
True False
Zero
0
0L
0.0
0j
Empty sequence
''
()
[]
Empty mapping {}
User deﬁned classes
__nonzero__()
__len__()
None
Boolean operations
and
or
not
Comparisons
Sequence types
in
not in
Class instances__cmp__() All objects
<
<=
>
>=
==
!=
Object identity
is
is not

BUILT-IN FUNCTIONS
• Refrain from using names that hide built in functions. Common errors: id,
min, max.
• If you are using vim add to your .vimrc: 
let python_highlight_builtins=1

LISTS ANDTUPLES
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.25), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> squares = [x**2 for x in range(10)]
>>>
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
List comprehension!
>>> import itertools
>>> import pprint
>>> pprint.pprint(list(itertools.permutations("spam")))

SETS
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket) # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit # fast membership testing
True
>>> 'crabgrass' in fruit
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b # letters in both a and b
set(['a', 'c'])
>>> a ^ b # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])
>>> # Similarly to list comprehensions, set comprehensions are also supported:
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
set(['r', 'd'])

DICTIONARIES
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
• Everything in Python is built with dictionaries: class properties, methods,
imports...
• If order is important there is ordered dictionary: OrderedDict.
Dictionary
comprehension

LOOPINGTECHNIQUES
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print i, v
...
0 tic
1 tac
2 toe
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print 'What is your {0}? It is {1}.'.format(q, a)
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
>>> for i in reversed(xrange(1,10,2)):
... print i,
...
9 7 5 3 1
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print f
...
apple
banana
orange
pear

GENERATORS
l = [1, 2, 3, 4, 5]
d = (str(x) for x in l if x % 2 == 0)
>>> <generator object <genexpr> at 0x106708410>
tuple(d)
>>> ('2', '4')
d
>>> <generator object <genexpr> at 0x106708410>
tuple(d)
>>>()
# Sum up the bytes transferred in an Apache server log using
# generator expressions
wwwlog = open("access-log")
bytecolumn = (line.rsplit(None,1)[1] for line in wwwlog)
bytes = (int(x) for x in bytecolumn if x != '-')
print "Total", sum(bytes)
def countdown(n):
print "Counting down from", n
while n > 0:
yield n
n -= 1
print "Done counting down"
for i in countdown(10):
print i

COROUTINES
def grep(pattern):
print "Looking for %s" % pattern
while True:
line = (yield)
if pattern in line:
print line,
g = grep("python")
g.next()
g.send("Yeah, but no, but yeah, but no")
g.send("A series of tubes")
g.send("python generators rock!")

NAMESPACES AND SCOPES
Namespace
Maps names to objects
Implemented as dictionaries
Examples
Built in names
Global names in a module
Local names in a function invocation
No relation between names in different
modules
Lifetime
Built in when Python starts (also called
__builtin__ module)
Global for a module when definition is read in
Local when the function is called, deleted
when function returns
Scope
Textual region of a Python program where a
namespace is directly accessible
Determined statically, used dynamically
What?
During execution, there are at least three
nested scopes:
Innermost scope, contains local names
Scopes of any enclosing functions
Current module's global names
Built in names
Assignments to names always go into the
innermost scope
What?
The global scope of a function defined in a
module is that module’s namespace, no
matter from where or by what alias the
function is called
Class definitions place yet another
namespace in the local scope.
#!/usr/bin/python
def multiply_b_f(value):
def multiply_by(x):
return x * value
return multiply_by
# Lexical scoping.
my_func = multiply_b_f(2)
value = 3
print my_func(10)
>>>
20

CLASSES
class Mapping:
def __init__(self, iterable):
self.items_list = []
self.__update(iterable)
def update(self, iterable):
for item in iterable:
self.items_list.append(item)
__update = update # Private copy of original update() method.
class MappingSubclass(Mapping):
def update(self, keys, values):
# provides new signature for update()
# but does not break __init__()
for item in zip(keys, values):
self.items_list.append(item)
class B:
pass
class C(B):
pass
class D(C):
pass
for c in [B, C, D]:
try:
raise c()
except D:
print "D"
except C:
print "C"
except B:
print "B"
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
• Data attributes override method attributes
with the same name.
• Passing an object is cheap since only a
pointer is passed by the implementation; and
if a function modiﬁes an object passed as an
argument, the caller will see the change.
class Foo(object):
# Class variable.
DUMMY = 1
def bar(self):
return self.DUMMY + 1
def baz(self, new_value):
self.DUMMY = new_value
a = Foo()
b = Foo()
b.baz(2)
# Which one fails?
assert Foo.DUMMY == a.DUMMY
assert Foo.DUMMY == b.DUMMY
# A: self.__class__.DUMMY

GENERATORVS. ITERATOR
• Generators and iterators work the same.
• But not in multithreaded environment!
Think about counters:
• You cannot call a generator that is
already executing.
• You can lock protect iterator state and
call it many times concurrently.
def squares(start, stop):
"""Generator."""
for i in xrange(start, stop):
yield i * i
class Squares(object):
"""Iterator."""
def __init__(self, start, stop):
self.start = start
self.stop = stop
def __iter__(self):
return self
def next(self):
# Lock here.
if self.start >= self.stop:
raise StopIteration
current = self.start * self.start
self.start += 1
return current
for i in squares(1, 5):
print i,
# Inline generator:
for i in (i*i for i in xrange(1, 5)):
print i,
sq_range = Squares(1, 5)
for i in sq_range:
print i,
>>> 1 4 9 16

FUNCTION ARGUMENTS
• Never use keyword argument for a function that doesn't explicitly deﬁne
one. If you do that you’ve introduced a global variable!
• In your tests use the function call the same way you use it in production
code: it can catch these bugs.
def foo(x, y):
print x ** y
foo(2, 3)
foo(2, y=3)
foo(x=2, y=3)
def foo(base, exponent):
print base ** exponent
foo(x=2, y=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'x'

CONTEXT MANAGERS
import sys
from StringIO import StringIO
class redirect_stdout:
def __init__(self, target):
# Save stdout and target.
self.stdout = sys.stdout
self.target = target
# Do this before.
def __enter__(self):
# Replace stdout with target.
sys.stdout = self.target
# Do this after.
def __exit__(self, type, value, tb):
# Restore stdout.
sys.stdout = self.stdout
out = StringIO()
with redirect_stdout(out):
# Print goes to StringIO object now!
print 'Test'
# Verify:
>>> out.getvalue() == 'Testn'
True
f = open("hello.txt")
try:
for line in f:
print line,
finally:
f.close()
with open("hello.txt") as f:
for line in f:
print line,
• __enter__() defines what the context manager should do at
the beginning of the block created by the with statement. Note
that the return value of __enter__ is bound to the target of the
with statement, or the name after the as.
• __exit__(self, exception_type,
exception_value, traceback) defines what the context
manager should do after its block has been executed (or
terminates).
• __enter__ and __exit__ can be useful for specific classes
that have well-defined and common behavior for setup and
cleanup.

DECORATORS
• Decorator expressions are
evaluated when the function is
defined, in the scope that contains
the function definition.
• The result must be a callable, which
is invoked with the function object
as the only argument.
• The returned value is bound to the
function name instead of the
function object. Multiple decorators
are applied in nested fashion.
import time
def timeit(func):
"""Decorator for measuring function run time.
Args:
func: Function to be wrapped, passed implicitly
through "@..."
call.
Returns:
Wrapped function.
"""
def function_call_wrap(*args, **kwargs):
try:
start_time = time.time()
return func(*args, **kwargs)
finally:
logger_func("%s() took %fms.", func.func_name,
(time.time() - start_time) * 1000)
return function_call_wrap
def sleep1():
time.sleep(1)
@timeit
def sleep2():
time.sleep(2)

RUNVS. IMPORT
• Module imports trigger __init__.py execution. Imports are
actually running a code.
• Running a code from the same folder would not see it as a module
and __init__.py wouldn’t run! Read an explanation at 
http://stackoverﬂow.com/a/465129.
• Stay on the safe side: know what you are initializing.
• from foo import bar — considered harmful.

MODULES AND EXCEPTIONS
• Modules or packages should deﬁne their own domain-speciﬁc base exception
class, which should be subclassed from the built-in Exception class.
• “Modules should have short, all-lowercase names.” (Though there are historical
exceptions: StringIO.)
• Module level exceptions enable catching all errors that can be raised by one
module only.Very useful for debugging and testing.
class Error(Exception):
"""Base class for exceptions in this module."""
class RedisLockError(Error):
"""Base class for lock exceptions."""

EXCEPTION CATCHING
• When catching exceptions, mention
speciﬁc exceptions whenever possible
instead of using a bare except: clause.
• If you want to catch all exceptions that
signal program errors, use except
Exception:(bare except is equivalent
to except BaseException:).
try:
do_something()
except:
# Diaper pattern.
print "Error"

def convert_to_named_tuple(original_class):
"""Replace class declaration with named tuple.
This decorator is to be used when one uses class for storing
constants.
Note: this will work only for classes with constants, not with any
other declared methods.
Example usage::
@convert_to_named_tuple
class important_constants(object):
PI = 3.141
e = 2.718
print important_constants.PI # Prints 3.141
important_constants.PI = 2 # Raises exception!
Args:
original_class: A class declaration.
Returns:
Named tuple object in place of the decorated class.
"""
@wraps(original_class)
def replace_class_with_named_tuple():
constant_value_dict = dict()
for attribute in original_class.__dict__:
if not attribute.startswith("__"):
constant_value_dict[attribute] = (
original_class.__dict__[attribute])
replacement_tuple = namedtuple(
original_class.__class__.__name__,
" ".join(constant_value_dict.iterkeys()))
args = constant_value_dict.values()
return replacement_tuple(*args)
return replace_class_with_named_tuple()
DOCUMENTATION
• PEP-257 talks about docstring
conventions.
• “Comments that contradict the code are
worse than no comments.Always make a
priority of keeping the comments up-to-
date when the code changes!”
• pydoc -p <port>: See all modules
in production. Use it as a local Python
library reference.

ARGPARSE
parser = argparse.ArgumentParser(
prog="smm",
description="Management")
parser.add_argument(
"--version",
action="version",
version="%(prog)s 0.1")
parser.add_argument(
"--log",
action="store",
choices=("debug", "info", "warning", "error", "critical"),
default="warning")
# Default arguments for each subparser: add/rm/list.
parent_parser = argparse.ArgumentParser(add_help=False)
parent_parser.add_argument(
"-l", "--labels",
required=True,
type=labels.valid_label_pair,
nargs="+",
metavar=("label1=value1", "label2=value2"),
help="labels as 'key=value' pairs")
"-m", "--machines",
required=True,
type=machines.valid_machine_name,
nargs="+",
metavar=("machine_1", "machine_2"),
help="machine names")
"--log",
action="store",
choices=("debug", "info", "warning", "error", "critical"),
default="warning")
# Subparsers for add, rm, and list inherit the same
subparsers = parser.add_subparsers(
title="subcommands",
description="valid subcommands",
dest="subparser_name",
help="sub-commands")
parser_add = subparsers.add_parser(
"add",
parents=[parent_parser],
help="add labels to machines")
parser_add.add_argument(
"add",
help="add labels",
action="store_true")
parser_add.set_defaults(func=add_machines)
#...
def main():
args = parser.parse_args()
logger.initialize_logger(args.log)
logger.LOG.debug("Parsed command line and initialized logger.")
logger.LOG.debug("Command line parsed: %s", args)
logger.LOG.debug("Dispatching:")
args.func(args)
logger.LOG.debug("Done!")
Try not to use optparse
module, it is deprecated.

GFLAGS
• Google’s command line parsing library: 
http://code.google.com/p/python-gflags/
• It has increased flexibility, including built-in support for Python
types, and the ability to define flags in the source file in which
they're used (major difference from OptParse).
FLAGS = gflags.FLAGS
gflags.DEFINE_integer(
"port",
9001,
"service port")
gflags.RegisterValidator(
"port",
lambda port: 1024 < port <= 65535,
message="must be in (1024, 65535] range")
def main(argv)
port = FLAGS.port

PEP8
• Python Style Checker: python.org/dev/peps/pep-0008/
• Read it, and then read it again. It will teach you to write better and
more reliable Python code.Add comments, be verbose, keep it clean.
• “Code should be written to minimize the time it would take for someone
else to understand it.” — “The Art of Readable Code”, Dustin Boswell,
Trevor Foucher.
• New code should (must) have test coverage. Use asserts.They will be
completely ignored when the code is run in optimized mode (python
-O).

PEP-8 ON IMPORTS
• Always use the absolute package path for all imports. Even now that PEP-328
(“Imports: Multi-Line and Absolute/Relative”) is fully implemented in Python
2.5, its style of explicit relative imports is actively discouraged; absolute
imports are more portable and usually more readable.
• Imports are always put at the top of the ﬁle, just after any module comments
and docstrings, and before module globals and constants. Imports should be
grouped in the following order: 
 
1. Standard library imports 
2. Related third party imports 
3. Local application/library speciﬁc imports
• You should put a blank line between each group of imports.

“IS NONE”VS.“== NONE”
• PEP 8 says: Comparisons to singletons like None
should always be done with is or is not, never
the equality operators (==, !=).
• Beware of writing if x when you really mean if
x is not None — e.g. when testing whether a
variable or argument that defaults to None was set
to some other value.The other value might have a
type (such as a container) that could be false in a
boolean context! A class is free to implement
comparison any way it chooses, and it can choose
to make comparison against None mean something
• Use x is not y instead of not x is y.
Operator priority can be confusing and the second
statement can be read as (not x) is y.
class Zero():
"""A class that is zero."""
def __nonzero__(self):
return False
class Len0():
"""A class with zero length."""
def __len__(self):
return 0
class Equal():
"""A class that is equal to everything."""
def __eq__(self, other):
return True
stuff = [None, False, 0, 0L, 0.0, 0j,
(), [], {}, set(), '', ﬂoat('NaN'), ﬂoat('inf'),
Zero(), Len0(), Equal()]
for x in stuff:
if x is None:
print("{} is None ".format(x))
if x==None:
print("{} == None ".format(x))
>>>
None is None
None == None
<__main__.Equal instance at 0x84a80> == None

__DEL__ AND MEMORY
class SomeClass(object):
pass
class SomeNastyClass(object):
# Confuse garbage collection by adding __del__ method. If
# circular reference is created it wouldn't know which one to
# dispose of ﬁrst and would let them stay in memory!
def __del__(self):
pass
def non_leaky_function():
"""Non leaky function."""
foo = SomeClass()
bar = SomeClass()
foo.other = bar
bar.other = foo
del foo
del bar
return
def leaky_function():
"""Leaky function."""
foo = SomeNastyClass()
bar = SomeNastyClass()
foo.other = bar
bar.other = foo
del foo
del bar
return
def log_memory_leaks(func, logger_func):
"""Decorator for detecting memory leaks.
Log what was not garbage collected after the function has returned.
Args:
func: Function to be wrapped, passed implicitly through "@..." call.
logger_func: Logging function to be called around the wrapped function.
Returns:
Wrapped function.
"""
@wraps(func)
# Force garbage collection.
gc.collect()
# Different type instance counters before and after the function run.
before = Counter([type(i) for i in gc.get_objects()])
try:
ﬁnally:
gc.collect()
# Count instances by type after the run. Ignore object "before"
# created in this decorator.
after = Counter(
[type(i) for i in gc.get_objects() if i is not before])
# Find instance types that have changed after the run.
instance_diff = {
i: after[i] - before[i] for i in after if after[i] != before[i]}
if instance_diff:
logger_func(
"Memory usage after %s(args=%s, kwargs=%s): %s",
func.func_name, args, kwargs, pprint.pformat(instance_diff))
Usecontextmanager:“with
...
:”

WHYTEST
• No standard scoping: once a variable has come into existence it remains
until the enclosing function exits and not when the enclosing block
terminates.
• No concept of data privacy, only obfuscation.
• No concept of declaration leads to ambiguity when you have multiple
scopes. Instead of having one simple var keyword, Python has the global
and nonlocal keywords (the latter is only available in Python 3).
• More errors are detected at run time than is desirable. Basically you have
to make sure that all your code has been executed before you can say that
the program is even semantically correct.
• Your friend: https://nose.readthedocs.org/en/latest/

PYCHARM COMMERCIAL
http://www.jetbrains.com/pycharm/
>>> # Python 2.X
>>> True == False
False
>>> True = True
>>> True = False
>>> True == True
True
>>> True == False
True

package main
import (
"fmt"
"runtime"
)
func summer(ch chan<- uint64, from uint64, to uint64) {
var sum uint64 = 0
for i := from; i <= to; i++ {
sum += i
}
// Send the result.
ch <- sum
}
func main() {
const upper uint64 = 1000000000
const workers uint64 = 8
var start_interval uint64 = 1
const step uint64 = upper / workers
// Make a channel that can buffer up to $workers numbers.
ch := make(chan uint64, workers)
// Use up to 8 CPUs. This should nicely use quad core CPU with
// hyperthreading.
runtime.GOMAXPROCS(8)
// Dispatch workers, each with a different number segment.
for i := uint64(0); i < workers; i++ {
go summer(ch, start_interval, start_interval+step-1)
start_interval += step
}
// Read out results as they keep arriving to the channel (we block on the
// channel until a value is ready).
var sum uint64 = 0
for i := uint64(0); i < workers; i++ {
sum += <-ch
}
fmt.Println(sum)
}
>
real 0m0.302s
user 0m2.165s
sys 0m0.004s
#!/usr/bin/python
print sum(xrange(1, 1000000001))
>
real 0m12.114s
user 0m12.087s
sys 0m0.012s
#!/usr/bin/perl
use integer; $sum = 0; $sum += $_ for (1 .. 1000000000); print $sum;
>
real 1m21.774s
user 1m21.656s
sys 0m0.061s
#include "stdio.h"
int main(int argc, char const *argv[]) {
long sum = 0;
for (long i = 1; i <= 1000000000L; sum+=i++)
;
printf("%ldn", sum);
return 0;
}
>
real 0m2.465s
user 0m2.461s
sys 0m0.002s
109
X
i=1
i = 500000000500000000
EXAMPLE: SUM

PARALLELIZE SUM!
#!/usr/bin/python
import multiprocessing
UPPER = 1000000000
WORKERS = 8
STEP = UPPER / WORKERS
pool = multiprocessing.Pool(processes=WORKERS)
ranges = (xrange(lo, hi + 1) for (lo, hi) in zip(xrange(1, UPPER, STEP),
xrange(STEP, UPPER + 1, STEP)))
print sum(pool.map(sum, ranges))
>
real 0m2.008s
user 0m13.991s
sys 0m0.051s
From 12 to 2 seconds.

FIBONACCI NUMBERS
f(n) =
8
><
>:
0 n = 0
1 n = 1
f(n 1) + f(n 2) otherwise
#!/usr/bin/python
from timeit import timeit
def fib(n):
assert n >= 0
if n == 0:
return 0
if n == 1:
return 1
return fib(n-1) + fib(n-2)
print(timeit(
stmt="fib(30)",
setup="from __main__ import fib",
number=1))
$ python3.3 fib.py
0.8095278141554445
#!/usr/bin/python
import time
def timeit(func):
try:
start_time = time.time()
finally:
print(time.time() - start_time)
def fib(n):
assert n >= 0
if n == 0:
return 0
if n == 1:
return 1
@timeit
def fib30():
fib(30)
fib30()
python3.3 fib.py
0.794215202331543
#!/usr/bin/python
from timeit import timeit
from functools import lru_cache
@lru_cache(maxsize=512)
def fib(n):
assert n >= 0
if n == 0:
return 0
if n == 1:
return 1
print(timeit(
stmt="fib(30)",
setup="from __main__ import fib",
number=1))
$python3.3 fib.py
0.0003443881869316101
f(30) = 832040

USEFUL LIBRARIES
https://pypi.python.org/pypi/pip
matplotlib
NumPy
django
PIL

CRITICISM
• Python is highly typed. Do you get function overloading based upon parameter type? No.
Can you stipulate the type of a parameter in a function declaration? No, this has to be
coded within the function.
• Mutable default arguments (def foo(a=”abc”, b=[])).
• Documentation is generally good, but quite often it doesn’t go into enough detail.
• It is deceptively easy to start with, but to write serious code you have to know hidden stuff.
• All function arguments are essentially global variables! If you rename them you can break
some code! Partially ﬁxed in Python 3+.
• White space complicates refactoring.
• Anonymous or lambda functions are limited in their ability. However one can declare a
named function in an inner scope and use that instead.

GIL
• GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once.
This lock is necessary mainly because CPython's memory management is not thread-safe.
However, since the GIL exists, other features have grown to depend on the guarantees that it
enforces.
• It prevents multithreaded CPython programs from taking full advantage of multiprocessor systems.

2.X OR 3.X
$ python
Python 2.7.2 (default, Oct 11 2012, 20:14:37)
[GCC 4.2.1 Compatible Apple Clang 4.0 (tags/Apple/clang-418.0.60)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 3/2
1
>>> ^D
$ python3.3
Python 3.3.1 (v3.3.1:d9893d13c628, Apr 6 2013, 11:07:11)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 3/2
1.5
>>> ^D
• Some libraries are still not ported to 3.X
• 2.7.X is the last 2.X version
• New features are added to 3.X, it is a better language.
• http://wiki.python.org/moin/Python2orPython3

GOODTO KNOW
• #!env python — it can mask the process name.You wouldn’t see
the name of the code running when listing processes on a machine.
• Unicode vs. normal strings: size difference exists for ASCII characters
as well. u“Aleksa” takes twice the size of “Aleksa” (or even four times!).
Differences in 2.X and 3.X.
• In all python projects you do not cd into a lower directory to run
things.You stay at the top and run everything from there so that all of
the system can access all the modules and ﬁles.
• http://www.aleksa.org/2013/03/python-resources.html

A tour of Python

Recommended

More Related Content

What's hot (20)

Similar to A tour of Python (20)

Recently uploaded (20)

A tour of Python