python.txt

`e versions-used
2.7; 3.3
`e show-version
`$[python -V]
`$[python --version]
`e implicit-prologue
`*import os, re, sys
`e hello-world
`c[2.x:]
`*print `=["Hello, world!"]
`c[3.x:]
`.print(`=["Hello, world!"])
`e file-suffixes
.py
`c[none]
.pyc
`e interpreter
`$[python foo.py]
`e repl
`$[python]
`e command-line-program
`$[python -c '`.print("hi")']
`e block-delimiters
: and offside rule
`e statement-terminator
newline or ;

newlines not separators inside (), [], {}, triple quote literals, or after backslash: \
`e source-code-encoding
`c[Python 3 source is UTF-8 by default]
# -*- coding: utf-8 -*-
`e end-of-line-comment
# comment
`e multiple-line-comment
`c[use triple quote string literal:]
'''comment line
another line'''
`e local-variable
`c[in function body:]
v = `=None
a, d = [], {}
x = 1
y, z = 2, 3
`e regions-which-define-lexical-scope
nestable (read only):
  function or method body
`e global-variable
g1, g2 = 7, 8
`*def swap_globals():
  `*global g1, g2
  g1, g2 = g2, g1
`e constant
`c[uppercase identifiers constant by convention]
PI = 3.14
`e assignment
`c[assignments can be chained but otherwise don't return values:]
v = 1
`e parallel-assignment
x, y, z = 1, 2, 3

`![raises `.ValueError:]
x, y = 1, 2, 3

`![raises `.ValueError:]
x, y, z = 1, 2
`e swap
x, y = y, x
`e compound-assignment-arithmetic-string-logical-bit
`c[do not return values:]
+= -= *= /= //= %= **=
+= *=
&= |= ^=
<<= >>= &= |= ^=
`e increment-and-decrement
`c[just use x += 1 and x -= 1]
`e null
`=None
`e null-test
v `*is `=None `c[slightly preferable to ==, as the latter can be overridden]
`e uninitialized-local-variable
`![raises `.NameError]
`e uninitialized-global-variable
`![raises `.NameError]
`e conditional-expression
x `*if x > 0 `*else -x
`e boolean-type
`.bool
`e true-and-false
`=True `=False
`e falsehoods
`=False `=None 0 0.0 '' [] {}
`e logical-operators
`*and `*or `*not
`e relational-operators
`c[relational operators are chainable:]
== != > < >= <=
`e compare-strings
`c[relational operators are chainable:]
== != > < >= <=
`e min-and-max
`.min(1, 2, 3)
`.max(1, 2, 3)

`.min([1, 2, 3])
`.max([1, 2, 3])
`e three-value-comparison
`c[removed from Python 3:]
`.cmp(0, 1)
`.cmp('do', 're')
`e integer-type
`.int
`e integer-literal
-4
`e float-type
`.float
`e arithmetic-operators
+ - * `c[see note] // %

`c[Python 2 does not have an operator which performs float division on integers. In Python 3 / always performs float division.]
`e integer-operators
`c[as above]
`e float-operators
`c[as above]
`e add-integer-and-float
`c[automatically coerced]
`e integer-division
13 // 5
`e divmod
q, r = `.divmod(13, 5)
`e integer-division-by-zero
`![raises `.ZeroDivisionError]
`e float-division
`.float(13) / 5
`c[Python 3:]
13 / 5
`e float-division-by-zero
`![raises `.ZeroDivisionError]
`e power
2**32
`e sqrt
`*import math
math.sqrt(2)
`e sqrt-1
`![raises `.ValueError:]
`*import math
math.sqrt(-1)
`![returns complex float:]
`*import cmath
cmath.sqrt(-1)
`e transcendental-functions
`*from math `*import exp, log, sin, cos, tan, asin, acos, atan, atan2
`e transcendental-constants
`*import math
math.pi math.e
`e float-truncation
`*import math

`.int(x)
`.int(`.round(x))
math.ceil(x)
math.floor(x)
`e absolute-value-and-signum
`.abs(x)

`*import math
math.copysign(1, x) `c[returns 1.0 or -1.0 for positive or negative floating zero; int zero is coerced to positive zero]
`e arbitrary-length-integer
`c[automatically promoted]
`e arbitrary-length-integer-operators
`c[as above]
`e integer-overflow
`c[becomes arbitrary length integer of type long]
`e float-overflow
`![raises `.OverflowError]
`e rational-type
fractions.Fraction
`e rational-construction
`*from fractions `*import Fraction
x = Fraction(22, 7)
`e rational-decomposition
x.numerator
x.denominator
`e complex-type
complex
`e complex-construction
z = 1 + 1.414j
`e complex-decomposition
`*import cmath
z.real
z.imag
cmath.phase(z)
`.abs(z)
z.conjugate()
`e complex-operators
`c[as above]
`e random-number-uniform-integer-uniform-float-normal-float
`*import random

random.randint(0, 99)

random.random()

random.gauss(0, 1)
`e random-seed
`*import random

random.seed(17)
seed = random.getstate()

random.setstate(seed)
`e bit-operators
<< >> & | ^ ~
`e binary-octal-and-hex-literals
0b101010
052
0x2a
`e radix-convert-integer-to-and-from-string-with-radix
`c[none]
`.int(`=["60"], 7)
`e string-type
`.str
`e string-literal
`=['don`%[\']t say "no"']
`=["don't say `%[\"]no`%[\"]"]
`=["don't " 'say "no"']
`=['''don't say "no"''']
`=["""don't say "no`%[\"]"""]
`e newline-in-literal
`c[triple quote literals only:]
`=['''first line
second line''']

`=["""first line
second line"""]
`e literal-escapes
`c[single and double quoted:]
`%[\newline \\ \' \" \a \b \f \n \r \t \v \ooo \xhh]

`c[Python 3:]
`%[\uhhhh \Uhhhhhhhh]
`e custom-delimiters
`e here-document
`e variable-interpolation
count = 3
item = 'ball'
`.print(`=['`%[{count}] `%[{item}]s'].format(
  `+[**]`.locals()))
`e expression-interpolation
`=['1 + 1 = `%[{}]'].format(1 + 1)
`e format
`c[old-style]
`=['lorem `%[%s %d %f]'] % ('ipsum', 13, 3.7)
`c[new-style]
fmt = `=['lorem `%[{0} {1} {2}]']
fmt.format('ipsum', 13, 3.7)
`e are-strings-mutable
no
`e copy-string
`c[not necessary]
`e concatenate-strings
s = `=['Hello, ']
s2 = s + `=['World!']

`c[juxtaposition can be used to concatenate literals:]
s2 = `=['Hello, ' "World!"]
`e replicate-string
hbar = `=['-'] `+* 80
`e translate-case
`=['lorem'].upper()
`=['LOREM'].lower()
`e capitalize
`*import string

'lorem'.capitalize()
string.capwords('lorem ipsum')
`e trim
`=[' lorem '].strip()
`=[' lorem'].lstrip()
`=['lorem '].rstrip()
`e pad
`=['lorem'].ljust(10)
`=['lorem'].rjust(10)
`=['lorem'].center(10)
`e number-to-string
`=['value: '] + `*[str](8)
`e string-to-number
7 + `.int('12')
73.9 + `.float('.037')

`![raises `.ValueError:]
`.int(`=['12A'])
`![raises `.ValueError:]
`.int(`=['A'])
`e join
`=[' '].join([`=['do'], `=['re'], `=['mi'], `=['fa']])
`![raises `.TypeError:]
`=[' '].join([1, 2, 3])
`e split
`=['do re mi fa'].split()
`e split-in-two
`=['do re mi fa'].split(`=None, 1)
`e split-and-keep-delimiters
re.split(`=['(\s+)'], `=['do re mi fa'])
`e prefix-and-suffix-test
'foobar'.startswith('foo')
'foobar'.endswith('bar')
`e string-length
`.len('lorem')
`e index-of-substring
`![raises `.ValueError if not found:]
`=['do re re'].index(`=['re'])
`=['do re re'].rindex(`=['re'])

`c[returns -1 if not found:]
`=['do re re'].find(`=['re'])
`=['do re re'].rfind(`=['re'])
`e extract-substring
`c[none]
`c[none]
`=['lorem ipsum'][6:11]
`e extract-character
`=['lorem ipsum'][6]
`e character-type
`c[essentially length-1 str]
`e character-literal
`c[same as string]
`e test-character
`c[operate on any strings, testing if all characters satisfy:]
`=['c'].isalpha()
`=['c'].isdigit()
`=['c'].isspace()
`=['c'].isupper()
`=['c'].islower()
`e chr-and-ord
`.chr(65)
`.ord(`=['A'])
`e to-array-of-characters
`.list(`=['abcd'])
`e translate-characters
`*from string `*import lowercase `*as ins
`*from string `*import maketrans

outs = ins[13:] + ins[:13]
`=['hello'].translate(maketrans(ins,outs))
`e delete-characters
`=["disemvowel me"].translate(`=None, "aeiou")
`e squeeze-characters
re.sub(`=['(\s)+'], `=[r'\1'], `=['too  much  space'])
`e literal-custom-delimited-literal
re.compile(`=['lorem|ipsum'])
`c[none]
`e character-class-abbreviations
`%[. \d \D \s \S \w \W]
`e anchors
`%[^ $ \A \b \B \Z]
`e match-test
`*if re.search(`=['1999'], s):
  `.print('party!')
`e case-insensitive-match-test
re.search(`=['lorem'], `=['Lorem'], re.I)
`e modifiers
re.I re.M re.S re.X
`e substitution
s = `=['do re mi mi mi']
s = re.compile(`=['mi']).sub(`=['ma'], s)
`e match-prematch-postmatch
m = re.search(`=['\d{4}'], s)
`*if m:
  match = m.group()
  prematch = s[0:m.start(0)]
  postmatch = s[m.end(0):`.len(s)]
`e group-capture
rx = `=['(\d{4})-(\d{2})-(\d{2})']
m = re.search(rx, `=['2010-06-03'])
yr, mo, dy = m.groups()
`e named-group-capture
rx = `=['^(?P<file>.+)\.(?P<suffix>.+)$']
m = re.search(rx, `=['foo.txt'])

m.groupdict()[`=['file']]
m.groupdict()[`=['suffix']]
`e scan
s = `=['dolor sit amet']
a = re.findall(`=['\w+'], s)
`e backreference-in-match-and-substitution
`c[none]

rx = re.compile(`=['(\w+) (\w+)'])
rx.sub(r`=['\2 \1'], `=['do re'])
`e recursive-regex
none
`e date-time-type
datetime.datetime
`e current-date-time
`*import datetime

t = datetime.datetime.now()
utc = datetime.datetime.utcnow()
`e to-unix-epoch-from-unix-epoch
`*from datetime `*import datetime `*as dt

epoch = `.int(t.strftime("%s"))
t2 = dt.fromtimestamp(1304442000)
`e current-unix-epoch
`*import datetime

t = datetime.datetime.now()
epoch = `.int(t.strftime("%s"))
`e strftime
t.strftime('%Y-%m-%d %H:%M:%S')
`e default-format-example
2011-08-23 19:35:59.411135
`e strptime
`*from datetime `*import datetime

s = '2011-05-03 10:00:00'
fmt = '%Y-%m-%d %H:%M:%S'
t = datetime.strptime(s, fmt)
`e parse-date-w-o-format
# pip install python-dateutil
`*import dateutil.parser

s = 'July 7, 1999'
t = dateutil.parser.parse(s)
`e date-subtraction
datetime.timedelta object

use total_seconds() method to convert to float representing difference in seconds
`e add-duration
`*import datetime

delta = datetime.timedelta(
  minutes=10,
  seconds=3)
t = datetime.datetime.now() + delta
`e local-timezone
a datetime object has no timezone information unless a tzinfo object is provided when it is created
`e arbitrary-timezone
# pip install pytz

`*import pytz
`*import datetime

tmz = pytz.timezone('Asia/Tokyo')
utc = datetime.datetime.utcnow()
utc_dt = datetime.datetime(
  *utc.timetuple()[0:5],
  tzinfo=pytz.utc)
jp_dt = utc_dt.astimezone(tmz)
`e timezone-name-offset-from-utc-is-daylight-savings
`*import time

tm = time.localtime()

time.tzname[tm.tm_isdst]
(time.timezone / -3600) + tm.tm_isdst

tm.tm_isdst
`e microseconds
t.microsecond
`e sleep
`*import time

time.sleep(0.5)
`e timeout
`*import signal, time

`*class Timeout(`.Exception): `*pass

`*def timeout_handler(signo, fm):
  `*raise Timeout()

signal.signal(signal.SIGALRM,
  timeout_handler)

`*try:
  signal.alarm(5)
  time.sleep(10)
`*except Timeout:
  `*pass
signal.alarm(0)
`e list-name
`.list
`e list-literal
a = [1, 2, 3, 4]
`e list-size
`.len(a)
`e empty-list
[]
`e empty-test
`*not a
`e head
a[0]
`e list-lookup
a[0]
`c[negative indices count from end:]
a[-1] `c[last element]
`e list-update
a[0] = 'lorem'
`e list-out-of-bounds
a = []
`![raises `.IndexError:]
a[10]
`![raises `.IndexError:]
a[10] = 'lorem'
`e index-of-element
a = [`=['x'], `=['y'], `=['y'], `=['z']]
i = a.index('y')
`e slice
`c[select 3rd and 4th elements:]
a[2:4]
a[2:2 + 2]
`e drop
a[2:]
`e last-and-butlast
a[-1]
a[:-1]
`e manipulate-back
a = [6, 7, 8]
a.append(9)
a.pop()
`e manipulate-front
a = [6, 7, 8]
a.insert(0, 5)
a.pop(0)
`e concatenate
a = [1, 2, 3]
a2 = a + [4, 5, 6]
a.extend([4, 5, 6])
`e list-replicate
a = [`=None] * 10

a = [`=None `*for i `*in `.range(0, 10)]
`e list-copy
`*import copy

a = [1,2,[3,4]]
a2 = a
a3 = `.list(a)
a4 = copy.deepcopy(a)
`e arrays-as-function-arguments
parameter contains address copy
`e iterate-over-elements
`*for i `*in [1,2,3]:
  `.print(i)
`e iterate-over-indices-and-elements
a = ['do', 're', 'mi', 'fa']
`*for i, s `*in `.enumerate(a):
  `.print('%s at index %d' % (s, i))
`e iterate-over-range
`c[use range(] in Python 3:)
`*for i `*in `.xrange(1, 1000001):
  code
`e instantiate-range-as-list
a = `.range(1, 11)
`c[Python 3:]
a = `.list(`.range(1, 11))
`e reverse
a = [1, 2, 3]

a[::-1]
`.reversed(a) `c[iterator]
a.reverse()
`e sort
a = ['b', 'A', 'a', 'B']

`.sorted(a)
a.sort()
`c[custom binary comparision removed from Python 3:]
a.sort(key=`.str.lower)
`e dedupe
a = [1, 2, 2, 3]

a2 = `.list(`.set(a))
a = `.list(`.set(a))
`e membership
7 `*in a
`e intersection
{1,2} & {2,3,4}
`e union
{1,2} | {2,3,4}
`e relative-complement-symmetric-difference
{1,2,3} - {2}

{1,2} ^ {2,3,4}
`e min-and-max-element
`.min([1,2,3])
`.max([1,2,3])
`e map
`.map(`*lambda x: x * x, [1,2,3])
`c[or use list comprehension:]
[x * x `*for x `*in [1,2,3]]
`e filter
`.filter(`*lambda x: x > 1, [1,2,3])
`c[or use list comprehension:]
[x `*for x `*in [1,2,3] `*if x > 1]
`e fold-from-left
`c[import needed in Python 3 only]
`*from functools `*import reduce

`.reduce(`*lambda x, y: x+y, [1,2,3], 0)
`e universal-test
`.all(i % 2 == 0 `*for i `*in [1,2,3,4])
`e existential-test
`.any(i % 2 == 0 `*for i `*in [1,2,3,4])
`e shuffle-and-sample
`*from random `*import shuffle, sample

a = [1, 2, 3, 4]
shuffle(a)

sample(a, 2)
`e zip
`c[array of 3 pairs:]
a = `.zip([1,2,3], ['a', 'b', 'c'])
`e map-literal
d = { 't':1, 'f':0 }
`e map-size
`.len(d)
`e map-lookup
d['t']
`e map-out-of-bounds
d = {}
`![raises `.KeyError:]
d['lorem']
`c[adds key/value pair:]
d['lorem'] = 'ipsum'
`e is-key-present
'y' `*in d
`e delete-entry
d = {1: `=True, 0: `=False}
`*del d[1]
`e from-array-of-pairs-from-even-length-array
a = [[`=['a'], 1], [`=['b'], 2], [`=['c'], 3]]
d = `.dict(a)

a = [`=['a'], 1, `=['b'], 2, `=['c'], 3]
d = `.dict(`.zip(a[::2], a[1::2]))
`e merge
d1 = {`=['a']: 1, `=['b']: 2}
d2 = {`=['b']: 3, `=['c']: 4}

d1.update(d2)
`e invert
to_num = {'t':1, 'f':0}
`c[dict comprehensions added in 2.7:]
to_let = {v:k `*for k, v
  `*in to_num.items()}
`e iteration
`*for k, v `*in d.iteritems():
  `ccode

`c[Python 3:]
`*for k, v `*in d.items():
  `ccode
`e keys-and-values-as-arrays
d.keys()

d.values()

`c[Python 3:]
`.list(d.keys())
`.list(d.values())
`e sort-by-values
`*from operator `*import itemgetter

pairs = `.sorted(d.iteritems(),
  key=itemgetter(1))

`*for k, v `*in pairs:
  `.print('{}: {}'.format(k, v))
`e default-value-computed-value
`*from collections `*import defaultdict

counts = defaultdict(`*lambda: 0)
counts[`=['foo']] += 1

`*class Factorial(dict):
  `*def __missing__(self, k):
    `*if k > 1:
      `*return k * self[k-1]
    `*else:
      `*return 1

factorial = Factorial()
`e define-function
`*def add3(x1, x2, x3):
  `*return x1 + x2 + x3
`e invoke-function
add3(1, 2, 3)
`e apply-function-to-array
a = [2, 3]


add3(1, *a)

`c[splat operator can only be used once, and must appear after other unnamed arguments]
`e missing-argument-behavior
`![raises `.TypeError] if number of arguments doesn't match function arity
`e default-argument
`*import math

`*def my_log(x, base=10):
  `*return math.log(x) / math.log(base)

my_log(42)
my_log(42, math.e)
`e variable-number-of-arguments
`*def first_and_last(*a):

  `*if `.len(a) >= 1:
    `.print('first: ' + `.str(a[0]))

  `*if `.len(a) >= 2:
    `.print('last: ' + `.str(a[-1]))
`e named-parameters
`*def fequal(x, y, eps=0.01):
  `*return abs(x - y) < eps

fequal(1.0, 1.001)
fequal(1.0, 1.001, eps=0.1**10)
`e pass-number-or-string-by-reference
not possible
`e pass-array-or-dictionary-by-reference
`*def foo(x, y):
  x[2] = 5
  y['f'] = -1

a = [1,2,3]
d = {'t':1, 'f':0}

foo(a, d)
`e return-value
`*return arg `c[or None, if not specified]
`e multiple-return-values
`*def first_and_second(a):
  `*return a[0], a[1]

x, y = first_and_second([1,2,3])
`e lambda
`c[body must be an expression:]
sqr = `*lambda x: x * x
`e lambda-invocation
sqr(2)
`e function-as-value
func = add
`e function-with-private-state
`c[state not private:]
`*def counter():
  counter.i += 1
  `*return counter.i

counter.i = 0
`.print(counter())
`e closure
`c[Python 3:]
`*def make_counter():
  i = 0
  `*def counter():
    nonlocal i
    i += 1
    `*return i
  `*return counter


nays = make_counter()
`e generator
`c[The itertools library contains standard generators. c.f. itertools.count(])

`*def make_counter():
  i = 0
  `*while True:
    i += 1
    `*yield i

nays = make_counter()
`.print(nays.next())
`e decorator
`*def logcall(f):
  `*def wrapper(*a, **opts):
    `.print(`=['calling '] + f.__name__)
    f(*a, **opts)
    `.print(`=['called '] + f.__name__)
  `*return wrapper

@logcall
`*def square(x):
  `*return x * x
`e operator-as-function
`*import operator

operator.mul(3, 7)

a = [`=['foo'], `=['bar'], `=['baz']]
operator.itemgetter(2)(a)
`e overload-operator
`*class Rational:
  `c[...]
  `*def __add__(self, o): `*return Rational(self.num * o.denom + o.num * self.denom, self.denom * o.denom)
`c[use special method names]
`e if
`*if 0 == n:
  `.print('no hits')
`*elif 1 == n:
  `.print('one hit')
`*else:
  `.print(`.str(n) + ' hits')
`e switch
`cnone
`e while
`*while i < 100:
  i += 1
`e for
`*for i `*in `.range(10):
  `.print(i)
`e break
`*break
`e continue
`*continue
`e break-continue-redo
`*break `*continue `c[none]
`e control-structure-keywords
`*elif `*else `*for `*if `*while
`e what-do-does
`![raises `.NameError unless a value was assigned to it]
`e statement-modifiers
`c[none]
`e base-exception
BaseException

`c[User-defined exceptions should subclass Exception.]

`c[In Python 2 old-style classes can be thrown.]
`e predefined-exceptions
BaseException
  SystemExit
  KeyboardInterrupt
  GeneratorExit
  Exception
    StopIteration
    StandardError
      BufferError
      ArithmeticError
        FloatingPointError
        OverflowError
        ZeroDivisionError
      AssertionError
      AttributeError
      EnvironmentError
       EOFError
      ImportError
      LookupError
        IndexError
        KeyError
      MemoryError
      NameError
      ReferenceError
      RuntimeError
        NotImplementedError
      SyntaxError
      SystemError
      TypeError
      ValueError
        UnicodeError

`c[Python 3 has a different tree]
`e raise-exception
`*raise `.Exception(`=['bad arg'])
`e catch-all-handler
`*try:
  risky()
`*except:
  `*print(`=['risky failed'])
`e re-raise-exception
`*try:
  `*raise `.Exception('bam!')
`*except:
  `.print(`=['re-raising...'])
  `*raise
`e catch-exception
`*try:
  risky()
`*except:
  `.print('risky failed')
`e global-variable-for-last-exception
last exception: sys.exc_info()[1]
`e define-exception
`*class Bam(`.Exception):
  `*def __init__(self):
    `*super(Bam, self).__init__('bam!')
`e catch-exception-by-type
`*try:
  `*raise Bam()
`*except Bam `*as e:
  `.print(e)
`e finally
acquire_resource()
`*try:
  risky()
`*finally:
  release_resource()
`e start-thread
`*class sleep10(threading.Thread):
  `*def run(self):
    time.sleep(10)

thr = sleep10()
thr.start()
`e wait-on-thread
thr.join()

`e standard-file-handles
sys.stdin sys.stdout sys.stderr
`e read-line-from-stdin
line = sys.stdin.readline()
`e end-of-file-behavior
returns string without newline or ''
`e chomp
line = line.rstrip('\r\n')
`e write-line-to-stdout
`.print(`=['Hello, World!'])
`e printf
`*import math

`.print('%.2f' % math.pi)
`e open-file-for-reading
f = `.open('/etc/hosts')
`e open-file-for-writing
f = `.open('/tmp/test', 'w')
`e set-file-handle-encoding
`*import codecs

fin = codecs.open('/tmp/foo',
  encoding='utf-8')

fout = codecs.open('/tmp/bar', 'w',
  encoding='utf-8')
`e open-file-for-appending
f = `.open('/tmp/err.log', 'a')
`e close-file
f.close()
`e close-file-implicitly
`*with `.open('/tmp/test', 'w') `*as f:
  f.write('lorem ipsum\n')
`e i-o-error
`![raise `.IOError exception]
`e encoding-error
`![raise `.UnicodeDecodeError on read]; `![raise `.UnicodeEncodeError on write]
`e read-line
f.readline()
`e iterate-over-file-by-line
`*for line `*in f:
  `.print(line)
`e read-file-into-array-of-strings
a = f.readlines()
`e read-file-into-string
s = f.read()
`e write-string
f.write('lorem ipsum')
`e write-line
f.write('lorem ipsum\n')
`e flush-file-handle
f.flush()
`e end-of-file-test
`c[?]
`e get-and-set-file-handle-position
f.tell()

f.seek(0)
`e temporary-file
`*import tempfile

f = tempfile.NamedTemporaryFile()


f.write('lorem ipsum\n')

`.print("tmp file: %s" % f.name)


f.close()

file is removed when file handle is closed
`e in-memory-file
`*from StringIO `*import StringIO

f = StringIO()

f.write('lorem ipsum\n')
s = f.getvalue()

`c[Python 3 moved StringIO to the io module]
`e file-exists-test-regular-test
os.path.exists('/etc/hosts')

os.path.isfile('/etc/hosts')
`e file-size
os.path.getsize('/etc/hosts')
`e is-file-readable-writable-executable
os.access('/etc/hosts', os.R_OK)

os.access('/etc/hosts', os.W_OK)

os.access('/etc/hosts', os.X_OK)
`e set-file-permissions
os.chmod('/tmp/foo', 0755)
`e last-modification-time
`*from datetime `*import datetime `*as dt

`c[unix epoch:]
t = os.stat('/etc/passwd').st_mtime

`c[datetime object:]
t2 = dt.fromtimestamp(t)
`e copy-file-remove-file-rename-file
`*import shutil


shutil.copy('/tmp/foo', '/tmp/bar')

os.remove('/tmp/foo')

shutil.move('/tmp/bar', '/tmp/foo')
`e create-symlink-symlink-test-readlink
os.symlink('/etc/hosts',
  '/tmp/hosts')

os.path.islink('/tmp/hosts')

os.path.realpath('/tmp/hosts')
`e generate-unused-file-name
`*import tempfile

f, path = tempfile.mkstemp(
  prefix='foo',
  dir='/tmp')
`e parse-csv
`*import csv

`*with open('foo.csv') `*as f:
  cr = csv.reader(f)
  `*for row `*in cr:
    print('\t'.join(row))
`e generate-csv
`*import csv

`*with open('foo.csv', 'w') `*as f:
  cw = csv.writer(f)
  cw.writerow(['one', 'une', 'uno'])
  cw.writerow(['two', 'deux', 'dos'])
`e json-generate-parse
`*import json

s = json.dumps({'t': 1, 'f': 0})
d = json.loads(s)
`e generate-xml
`*import xml.etree.ElementTree as ET

builder = ET.TreeBuilder()

builder.start('a', {})

builder.start('b', {'id': '123'})

builder.data('foo')

builder.end('b')

builder.end('a')
et = builder.close()

`c[<a><b id="123">foo</b></a>:]

`.print(ET.tostring(et))
`e parse-xml-all-nodes-matching-xpath-query-first-node-matching-xpath-query
`*from xml.etree `*import ElementTree

xml = '<a><b><c ref="3">foo</c></b></a>'

`![raises xml.etree.ElementTree.ParseError]

`c[if not well-formed:]
doc = ElementTree.fromstring(xml)

nodes = doc.findall('b/c')
`.print(`.len(nodes))
`.print(nodes[0].text)

node = doc.find('b/c')
`.print(node.text)
`.print(node.attrib['ref'])
`e parse-html
# pip install beautifulsoup4
`*import bs4

html = `.open('foo.html').read()
doc = bs4.BeautifulSoup(html)

`*for link `*in doc.find_all('a'):
  `.print(link.get('href'))
`e working-directory
old_dir = os.path.abspath('.')


os.chdir('/tmp')
`e build-pathname
os.path.join('/etc', 'hosts')
`e dirname-and-basename
os.path.dirname('/etc/hosts')

os.path.basename('/etc/hosts')
`e absolute-pathname-and-tilde-expansion
`c[symbolic links are not resolved:]

os.path.abspath('foo')

os.path.abspath('/foo')

os.path.abspath('../foo')

os.path.abspath('./foo')

os.path.expanduser('~/foo')
`e iterate-over-directory-by-file
`*for filename `*in os.listdir('/etc'):
  `.print(filename)
`e glob-paths
`*import glob

`*for path `*in glob.glob('/etc/*'):
  `.print(path)
`e make-directory
dirname = '/tmp/foo/bar'
`*if `*not os.path.isdir(dirname):
  os.makedirs(dirname)
`e recursive-copy
`*import shutil


shutil.copytree('/tmp/foodir',
  '/tmp/bardir')
`e remove-empty-directory
os.rmdir('/tmp/foodir')
`e remove-directory-and-contents
`*import shutil


shutil.rmtree('/tmp/foodir')
`e directory-test
os.path.isdir('/tmp')
`e generate-unused-directory
`*import tempfile

path = tempfile.mkdtemp(dir='/tmp',
  prefix='foo')
`e system-temporary-file-directory
`*import tempfile


tempfile.gettempdir()
`e command-line-arguments-and-script-name
sys.argv[1:]

sys.argv[0]
`e get-and-set-environment-variable
os.getenv('HOME')


os.environ['PATH'] = '/bin'
`e get-pid-parent-pid
os.getpid()

os.getppid()
`e get-user-id-and-name
`*import getpass


os.getuid()

getpass.getuser()
`e exit
sys.exit(0)
`e set-signal-handler
`*import signal

`*def handler(signo, frame):
  `.print('exiting...')
  sys.exit(1)


signal.signal(signal.SIGINT, handler)
`e executable-test
os.access('/bin/ls', os.X_OK)
`e external-command
`*if os.system('ls -l /tmp'):
  `*raise `.Exception('ls failed')
`e escaped-external-command
`*import subprocess

cmd = ['ls', '-l', '/tmp']
`*if subprocess.call(cmd):
  `*raise `.Exception('ls failed')
`e backticks
`*import subprocess

cmd = ['ls', '-l', '/tmp']
files = subprocess.check_output(cmd)
`e command-line-options-boolean-option-option-with-argument-usage
`*import argparse

parser = argparse.ArgumentParser()

parser.add_argument('positional_args',
  nargs='*',
  metavar='ARG')

parser.add_argument('--file', '-f',
  dest='file')

parser.add_argument('--verbose', '-v',
  dest='verbose',
  action='store_true')

args = parser.parse_args()

the_file = args.file
verbose = args.verbose

`c[The flags -h and --help and the usage message are generated automatically. Positional arguments are in args.positional_args. Options can follow positional arguments.]
`e load-library
`c[searches sys.path for foo.pyc or foo.py:]
`*import foo
`e load-library-in-subdirectory
`c[foo must contain __init__.py file]
`*import foo.bar
`e hot-patch
reload(foo)
`e load-error
`![raises `.ImportError if library not found; exceptions generated when parsing library propagate to client]
`e main-routine-in-library
`*if __name__ == '__main__':
  `c[code]
`e library-path
sys.path


sys.path.append('/some/path')
`e library-path-environment-variable
`$[PYTHONPATH=~/lib python foo.py]
`e library-path-command-line-option
`e simple-global-identifiers
built-in functions
`e multiple-label-identifiers
modules
`e label-separator
foo.bar.baz()
`e root-namespace-definition
`e declare-namespace
put declarations in foo.py
`e child-namespace-declaration
foo must be in sys.path:

`$[mkdir foo]
`$[touch foo/__init__.py]
`$[touch foo/bar.py]
`e namespace-alias
`*import foo `*as fu
`e unqualified-import-of-namespace
`*from foo `*import *
`e unqualified-import-of-all-subnamespaces
`c[subnamespaces in list __all__ of foo/__init__.py are imported]
`*from foo `*import *
`e unqualified-import-of-definitions
`*from foo `*import bar, baz
`e list-installed-packages-install-a-package
`$[pip freeze]
`$[pip install jinja2]
`e package-specification-format
`c[in setup.py:]
#!/usr/bin/env python
`*from distutils.core `*import setup
setup(
  name='foo',
  author='Joe Foo',
  version='1.0',
  description='a package',
  py_modules=['foo'])
`e define-class
`*class Int(class):
  `*def __init__(self, v=0):
    self.value = v
`e create-object
i = Int()
i2 = Int(7)
`e instance-variable-visibility
public; attributes starting with underscore private by convention
`e get-and-set-instance-variable
v = i.value

i.value = v + 1
`e define-method
`*def plus(self,v):
  `*return self.value + v
`e invoke-method
i.plus(7)
`e define-class-method
@classmethod
`*def get_instances(cls):
  `*return Counter.instances
`e invoke-class-method
Counter.get_instances
`e define-class-variable

`e get-and-set-class-variable

`e handle-undefined-method-invocation
`*def __getattr__(self, name):
  s = 'no def: ' + name + ' arity: %d'

  `*return `*lambda *a: print(s % len(a))
`e alias-method

`e destructor
`*def __del__(self):
  `.print('bye, %d' % self.value)
`e subclass
`*class Counter(Int):

  instances = 0

  `*def __init__(self, v=0):
    Counter.instances += 1
    Int.__init__(self, v)

  `*def incr(self):
    self.value += 1
`e mixin

`e overload-operator

`e object-id
`.id(o)
`e inspect-type
`.type([]) == `.list
`e basic-types
`.NoneType
`.bool
`.int
`.long
`.float
`.str
SRE_Pattern
datetime
`.list
array
`.dict
`.object
`.file
`e inspect-class
o.__class__ == Foo

`.isinstance(o, Foo)
`e inspect-class-hierarchy
o.__class__.__bases__
`e has-method
hasattr(o, 'reverse')
`e message-passing
`*for i `*in range(1,10):
  getattr(o, 'phone'+`.str(i))(`=None)
`e eval
argument of eval must be an expression:
`*while `=True:
  `.print(`.eval(sys.stdin.readline()))
`e list-obj-object-methods
[m `*for m `*in dir(o)
  `*if callable(getattr(o,m))]
`e list-object-attributes
`.dir(o)
`e list-loaded-libraries

`e list-loaded-namespaces
`.dir()
`e inspect-namespace
`*import urlparse


`.dir(urlparse)
`e pretty-print
`*import pprint

d = {'lorem':1, 'ipsum':[2,3]}


pprint.PrettyPrinter().pprint(d)
`e source-line-number-and-file-name
`*import inspect

cf = inspect.currentframe()

cf.f_lineno

cf.f_code.co_filename
`e command-line-documentation
`$[pydoc math]

`$[pydoc math.atan2]
`e get-local-hostname-dns-lookup-reverse-dns-lookup
`*import socket

host = socket.gethostname()
ip = socket.gethostbyname(host)
host2 = socket.gethostbyaddr(ip)[0]
`e http-get
`*import httplib

url = 'www.google.com'
conn = httplib.HTTPConnection(url)

conn.request("GET", '/')

resp = conn.getresponse()

`*if resp.status == httplib.OK:
  s = resp.read()
`e http-post
`*import httplib
`*import urllib

url = 'www.acme.com'
conn = httplib.HTTPConnection(url)
data = urllib.urlencode({
  'item': 'anvil',
  'qty': 1})

conn.request('POST', '/orders', data)

resp = conn.getresponse()

`*if resp.status == httplib.OK:
  s = resp.read()
`e serve-working-directory
`$[python -m SimpleHTTPServer 8000]
`e absolute-url-from-base-and-relative-url
`*import urlparse


urlparse.urljoin('http://google.com',
  'analytics')
`e parse-url
`c[Python 3 location: urllib.parse]
`*import urlparse

url = 'http://google.com:80/foo?q=3#bar'
up = urlparse.urlparse(url)

protocol = up.scheme
hostname = up.hostname
port = up.port
path = up.path
query_str = up.query
fragment = up.fragment

`c[returns dict of lists:]
params = urlparse.parse_qs(query_str)
`e url-encode-decode
`c[Python 3 location: urllib.parse]
`*import urllib


urllib.quote_plus("lorem ipsum?")

urllib.unquote_plus("lorem+ipsum%3F")
`e base64-encode-decode
`*import base64

s = `.open('foo.png').read()
b64 = base64.b64encode(s)
s2 = base64.b64decode(b64)
`e test-class
`*import unittest

`*class TestFoo(unittest.TestCase):
  `*def test_01(self):
    self.assertTrue(True, 'not True!')

`*if __name__ == `=['__main__']:
  unittest.main()
`e run-tests-run-test-method
`$[python test_foo.py]

`$[python test_foo.py TestFoo.test_01]
`e equality-assertion
s = 'do re me'
self.assertEqual('do re me',
  s,
  's: {}'.format(s))
`e approximate-assertion
x = 10.0 * (1.0 / 3.0)
y = 10.0 / 3.0

`c[default for delta is 0.1**7]
self.assertAlmostEqual(x, y, delta=0.1**6)
`e regex-assertion
s = 'lorem ipsum'
`c[uses re.search, not re.match:]
self.assertRegexpMatches(s, 'lorem')
`e exception-assertion
a = []
`*with self.assertRaises(IndexError):
  a[0]
`e mock-method
# pip install mock
`*import mock

foo = Foo()

foo.run = mock.MagicMock(return_value=7)

self.assertEqual(7, foo.run(13))

foo.run.assert_called_once_with(13)
`e setup
`c[in class TestFoo:]
`*def setUp(self):
  `.print('setting up')
`e teardown
`c[in class TestFoo:]
`*def tearDown(self):
  `.print('tearing down')
`e check-syntax
`*import py_compile

`c[precompile to bytecode:]

py_compile.compile('foo.py')
`e stronger-warnings
`$[python -t foo.py]

`$[python -3t foo.py]
`e lint
`$[sudo pip install pylint]

`$[pylint foo.py]
`e source-cleanup
`$[sudo pip install pep8]

`$[pep8 foo.py]
`e run-debugger
`$[python -m pdb foo.py]
`e debugger-commands
h l n s b c w u d p q
`e benchmark-code
`*import timeit


timeit.timeit('i += 1',
  'i = 0',
  number=1000000)
`e profile-code
`$[python -m cProfile foo.py]
`e java-version
Jython 2.5
compatible with Python 2.5 :(
`e java-repl
`$[jython]
`e java-interpreter
`$[jython]
`e java-compiler
`e java-prologue
`*import java
`e java-new
rnd = java.util.Random()
`e java-method
rnd.nextFloat()
`e java-import
`*from java.util `*import Random
rnd = Random()
`e non-bundled-java-libraries
`*import sys
sys.path.append('path/to/mycode.jar')
`*import MyClass
`e java-shadowing-avoidance
`*import java.io as javaio
`e convert-native-array-to-java-array
`*import jarray
jarray.array([1, 2, 3], 'i')
`e are-java-classes-subclassable
yes
`e are-java-class-open
no