Python Notes/Cheat Sheet

Comments
Operators
# from the hash symbol to the end of a line
Operator Functionality
+ Addition (also string, tuple, list
Code blocks concatenation)
Delineated by colons and indented code; and not - Subtraction (also set difference)
the curly brackets of C, C++ and Java.
* Multiplication (also string, tuple, list
def is_fish_as_string(argument):
replication)
if argument:
/ Division
return ‘fish’
else: % Modulus (also a string format
return ‘not fish’ function,
but use deprecated)
Note: Four spaces per indentation level is the
// Integer division rounded towards
Python standard. Never use tabs: mixing tabs and
minus
spaces produces hard-to-find errors. Set your
infinity
editor to convert tabs to spaces.
** Exponentiation
Line breaks =, -=, +=, Assignment operators
/=,
Typically, a statement must be on one line.
*=, %=, //=,
Bracketed code - (), [] or {} - can be split across
**=
lines; or (if you must) use a backslash \ at the end
==, !=, <, Boolean comparisons
of a line to continue a statement on to the next
<=,
line (but this can result in hard to debug code).
>=, >
and, or, not Boolean operators
Naming conventions
in, not in Membership test operators
Style Use
is, is not Object identity operators
StudlyCase Class names
|, ^, &, ~ Bitwise: or, xor, and, compliment
joined_lower Identifiers, functions; and class <<, >> Left and right bit shift
methods, attributes
; Inline statement separator
_joined_lower Internal class attributes # inline statements discouraged
joined_lower Private class attributes
Hint: float('inf') always tests as larger than any
# this use not recommended
number, including integers.
joined_lower Constants
ALL_CAPS
Modules
Modules open up a world of Python extensions
Basic object types (not a complete list)
that can be imported and used. Access to the
Type Examples
functions, variables and classes of a module
None None # singleton null object
depend on how the module was imported.
Boolean True, False
Import method Access/Use syntax
integer -1, 0, 1, sys.maxint
import math math.cos(math.pi/3)
long 1L, 9787L # arbitrary length ints
import math as m m.cos(m.pi/3)
float 3.14159265
# import using an alias
inf, float('inf') # infinity
from math import cos,pi cos(pi/3)
-inf # neg
# only import specifics
infinity nan, float('nan') #
from math import * log(e)
not a number
# BADish global import
complex 2+3j # note use of j
Global imports make for unreadable code!!!
string 'I am a string', "me too"
'''multi-line string''',
Oft used modules
"""+1""" r'raw string',
b'ASCII string'
u'unicode string'
tuple empty = () # empty tuple
(1, True, 'dog') # immutable list
list empty = [] # empty list
[1, True, 'dog'] # mutable list
set empty = set() # the empty set
set(1, True, 'a') # mutable
dictionary empty = {} # mutable object
{'a': 'dog', 7: 'seven’, True: 1}
file f = open('filename', 'rb')
Note: Python has four numeric types (integer, float,
long and complex) and several sequence types
including strings, lists, tuples, bytearrays, buffers,
and xrange objects.
Module Purpose
Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 1
datetime Date and time functions
time
math Core math functions and the
constants pi
and e
pickle Serialise objects to a file
os Operating system interfaces
os.path
re A library of Perl-like regular
expression
operations
string Useful constants and classes
sys System parameters and functions
numpy Numerical python library
pandas R DataFrames for Python
matplotlib Plotting/charting for Python

Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 2
If - flow control Objects and variables (AKA identifiers)
if condition: # for example: if x < 5:  Everything is an object in Python (in the sense
statements
that it can be assigned to a variable or passed
elif condition: # optional – can be multiple
statements as an argument to a function)
else: # optional  Most Python objects have methods and
statements attributes. For example, all functions have
the built-in attribute
For - flow control doc , which returns the doc string defined in
for x in iterable: the function's source code.
statements  All variables are effectively "pointers", not
else: # optional completion code "locations". They are references to objects;
statements and often called identifiers.
 Objects are strongly typed, not identifiers
While - flow control  Some objects are immutable (int, float, string,
while condition: tuple, frozenset). But most are mutable
statements (including: list, set, dictionary, NumPy arrays,
else: # optional completion code etc.)
statements  You can create our own object types by
defining a new class (see below).
Ternary statement
id = expression if condition else expression Booleans and truthiness
x = y if a > b else z - 5 Most Python objects have a notion of "truth".
False True
Some useful adjuncts: None
 pass - a statement that does nothing 0 Any number other than 0
 continue - moves to the next loop iteration int(False) #  0 int(True) #  1
 break - to exit for and while loop "" " ", 'fred',
Trap: break skips the else completion code # the empty string 'False' # all
other strings
Exceptions – flow control () [] {} set() [None], (False), {1, 1}
try: # empty containers # non-empty containers,
statements including those containing
except (tuple_of_errors): # can be multiple False or None.
statements
else: # optional no exceptions
You can use bool() to discover the truth status of
statements
finally: # optional all an object.
statements a = bool(obj) # the truth of obj

Common exceptions (not a complete list) It is pythonic to use the truth of objects.
Exception Why it happens if container: # test not empty
AsserionError Assert statement failed # do something
while items: # common looping idiom
AttributeError Class attribute assignment or item = items.pop()
reference failed # process item
IOError Failed I/O operation
ImportError Failed module import
Specify the truth of the classes you write using the
IndexError Subscript out of range
nonzero () magic method.
KeyError Dictionary key not found
MemoryError Ran out of memory
NameError Name not found Comparisons
TypeError Value of the wrong type Python lets you compare ranges, for example
if 1 < x < 100: # do something ...
ValueError Right type but wrong value

Tuples
Raising errors
Tuples are immutable lists. They can be
Errors are raised using the raise statement
searched, indexed and iterated much like lists
raise ValueError(value)
(see below). List methods that do not change the
list also work on tuples.
Creating new errors
a = () # the empty tuple
class MyError(Exception):
a = (1,) #  note comma # one item tuple
def init (self, value):
a = (1, 2, 3) # multi-item tuple
self.value = value
a = ((1, 2), (3, 4)) # nested tuple
def str (self):
return repr(self.value) a = tuple(['a', 'b']) # conversion
Note: the comma is the tuple constructor, not the
parentheses. The parentheses add clarity.

The Python swap variable idiom

a, b = b, a # no need for a temp variable
This syntax uses tuples to achieve its magic.
Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 3
String (immutable, ordered, characters) List (mutable, indexed, ordered container)
s = 'string'.upper() # STRING Indexed from zero to length-1
s = 'fred'+'was'+'here' # concatenation a = [] # the empty list
s = ''.join(['fred', 'was', 'here']) # ditto a = ['dog', 'cat', 'bird'] # simple list
s = 'spam' * 3 # replication
a = [[1, 2], ['a', 'b']] # nested lists
s = str(x) # conversion a = [1, 2, 3] + [4, 5, 6] # concatenation
a = [1, 2, 3] * 456 # replication
String iteration and sub-string searching a = list(x) # conversion
for character in 'str': # iteration
print (ord(character)) # 115 116 114 List comprehensions (can be nested)
for index, character in enumerate('str') Comprehensions: a tight way of creating lists
print (index, character) t3 = [x*3 for x in [5, 6, 7]] # [15, 18, 21]
if 'red' in 'Fred': # searching
z = [complex(x, y) for x in range(0, 4, 1)
print ('Fred is red') # it prints!
for y in range(4, 0, -1) if x > y]
# z --> [(2+1j), (3+2j), (3+1j)]
String methods (not a complete list)
capitalize, center, count, decode, encode, Iterating lists
endswith, expandtabs, find, format, index, L = ['dog', 'cat', 'turtle']
isalnum, isalpha, isdigit, islower, isspace, istitle, for item in L
isupper, join, ljust, lower, lstrip, partition, replace, print (item)
rfind, rindex, rjust, rpartition, rsplit, rstrip, split, for index, item in enumerate(L):
splitlines, startswith, strip, swapcase, title, print (index, item)
translate, upper, zfill
Searching lists
String constants (not a complete list) L = ['dog', 'cat', 'turtle']; value = 'cat'
if value in L:
from string import * # I'm bad ... count = L.count(value)
print ((digits, hexdigits, letters,
first_occurrence = L.index(value)
lowercase, uppercase, punctuation))
if value not in L:
print 'list is missing {}'.format(value)
Old school string formatting (using % oper)
print ("It %s %d times" % ['occurred', 5]) List methods (not a complete list)
# prints: 'It occurred 5 times'
Method What it does
l.append(x) Add x to end of list
Code Meaning l.extend(other) Append items from other
s String or string conversion l.insert(pos, x) Insert x at position
c Character del l[pos] Delete item at pos
d Signed decimal integer Remove first occurrence of x;
l.remove(x)
u Unsigned decimal integer An
H or h Hex integer (upper or lower case) error if no x
f Floating point l.pop([pos]) Remove last item from list
E or e Exponent (upper or lower case E) (or item from pos); An error if
G or g The shorter of e and f (u/l case) empty
% Literal '%' list
l.index(x) Get index of first occurrence
'%s' % math.pi # --> '3.14159265359' of
'%f' % math.pi # --> '3.141593' x; An error if x not found
'%.2f' % math.pi # --> '3.14'
'%.2e' % 3000 # --> '3.00e+03' l.count(x) Count the number of times x
'%03d' % 5 # --> '005' is
found in the list
l.sort() In place list sort
New string formatting (using format method)
l.reverse(x) In place list reversal
Uses: 'template-string'.format(arguments)
Examples (using similar codes as above):
'Hello {}'.format('World')# 'Hello World' List slicing
'{}'.format(math.pi) # ' 3.14159265359' x = [0, 1, 2, 3, 4, 5, 6, 7, 8] # play data
x[2] # 3rd element - reference not slice
'{0:.2f}'.format(math.pi) # '3.14'
'{0:+.2f}'.format(5) # '+5.00' x[1:3] # 2nd to 3rd element (1, 2)
'{:.2e}'.format(3000) # '3.00e+03' x[:3] # The first three elements (0,1,2)
'{:0>2d}'.format(5) # '05' (left pad) x[-3:] # last three elements
'{:x<3d}'.format(5) # '5xx' (rt. pad) x[:-3] # all but the last three elements
'{:,}'.format(1000000) # '1,000,000' x[:] # every element of x – copies x
'{:.1%}'.format(0.25) # '25.0%' x[1:-1] # all but first and last element
'{0}{1}'.format('a', 'b') # 'ab' x[::3] # (0, 3, 6, 9, …) 1st then every 3rd
'{1}{0}'.format('a', 'b') # 'ba' x[1:5:2]# (1,3) start 1, stop >= 5, every2nd
'{num:}'.format(num=7) # '7' (named args) Note: All Python sequence types support the
above index slicing (strings, lists, tuples,
bytearrays, buffers, and xrange objects)

Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 4
Set (unique, unordered container) Dictionary (indexed, unordered map-container)
A Python set is an unordered, mutable collection A mutable hash map of unique key=value pairs.
of unique hashable objects. a = {} # empty dictionary
a = set() # empty set a = {1: 1, 2: 4, 3: 9} # simple dict
a = {'red', 'white', 'blue'} # simple set a = dict(x) # convert paired data
a = set(x) # convert list # next example – create from a list
Trap: {} creates empty dict, not an empty set l = ['alpha', 'beta', 'gamma', 'delta']
a = dict(zip(range(len(l)), l))
Set comprehensions # Example using string & generator
# a set of selected letters... expression
s = {e for e in 'ABCHJADC' if e not in 'AB'} s = 'a=apple,b=bird,c=cat,d=dog,e=egg'
# --> {'H', 'C', 'J', 'D'} a = dict(i.split("=") for i in s.split(","))
# {'a': 'apple', 'c': 'cat', 'b': 'bird',
# a set of tuples ...
s = {(x,y) for x in range(-1,2) # 'e': 'egg', 'd': 'dog'}
for y in range (-1,2)}
Trap: set contents need to be immutable Dictionary comprehensions
to be hashable. So you can have a Conceptually like list comprehensions; but it
set of tuples, but not a set of lists. constructs a dictionary rather than a list
a = { n: n*n for n in range(7) }
Iterating a set # a -> {0:0, 1:1, 2:4, 3:9, 4:16, 5:25,6:36}
for item in set: odd_sq = { n: n*n for n in range(7) if n%2 }
print (item) # odd_sq -> {1: 1, 3: 9, 5: 25}
# next example -> swaps the key:value pairs
a = { val: key for key, val in a.items() }
Searching a set # next example -> count list occurrences
if item in set: l = [1,2,9,2,7,3,7,1,22,1,7,7,22,22,9,0,9,0]
print (item) c = { key: l.count(key) for key in set(l) }
if item not in set: # c -> {0:2, 1:3, 2:2, 3:1, 7:4, 9:3, 22:3}
print ('{} is missing'.format(item))
Iterating a dictionary
Set methods (not a complete list) for key in dictionary:
Method What it does print (key)
len(s) Number of items in set for key, value in dictionary.items():
s.add(item) Add item to set print (key, value)
s.remove(item) Remove item from set. Raise
KeyError if item not found. Searching a dictionary
s.discard(item) Remove item from set if if key in dictionary:
present. print (key)
s.pop() Remove and return an
arbitrary item. Raise KeyError Merging two dictionaries
on empty merged = dict_1.copy()
set. merged.update(dict_2)
s.clear() Remove all items from set
item in s True or False Dictionary methods (not a complete list)
item not in s True or False Method What it does
iter(s) An iterator over the items in len(d) Number of items in d
the d[key] Get value for key or raise
set (arbitrary order) the
s.copy() Get shallow copy of set KeyError exception
s.isdisjoint(o) True if s has not items in d[key] = value Set key to value
common with other set o del d[key] deletion
s.issubset(o) Same as set <= other key in d True or False
s.issuperset(o) Same as set >= other key not in d True or False
s.union(o[, ...]) Return new union set iter(d) An iterator over the keys
s.intersection(o) Return new intersection d.clear() Remove all items from d
s.difference(o) Get net set of items in s but d.copy() Shallow copy of dictionary
not d.get(key[, def]) Get value else default
others (Same as set – other) d.items() Dictionary's (k,v) pairs
d.keys() Dictionary's keys
Frozenset d.pop(key[, def]) Get value else default;
Similar to a Python set above, but immutable (and remove key from dictionary
therefore hashable). d.popitem() Remove and return an
f = frozenset(s) # convert set arbitrary (k, v) pair
f = frozenset(o) # convert other d.setdefault(k[,def])) If k in dict return its value
otherwise set def
d.update(other_d) Update d with key:val pairs
from other
d.values() The values from dict

Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 5
Key functions (not a complete list) Using functions
Function What it does When called, functions can take positional and
abs(num) Absolute value of num named arguments.
all(iterable) True if all are True
any(iterable) True if any are True For example:
bytearray(source) A mutable array of bytes result = function(32, aVar, c='see', d={})
callable(obj) True if obj is callable
chr(int) Character for ASCII int Arguments are passed by reference (ie. the
complex(re[, im]) Create a complex number objects are not copied, just the references).
divmod(a, b) Get (quotient, remainder)
enumerate(seq) Get an enumerate object, Writing a simple function
with def funct(arg1, arg2=None, *args, **kwargs):
next() method returns an """explain what this function does"""
(index, element) tuple statements
eval(string) Evaluate an expression return x # optional statement
filter(fn, iter) Construct a list of elements Note: functions are first class objects that get
from instantiated with attributes and they can be
iter for which fn() returns True referenced by variables.
float(x) Convert from int/string
getattr(obj, str) Like obj.str Avoid named default mutable arguments
hasattr(obj, str) True if obj has attribute Avoid mutable objects as default arguments.
hex(x) From in to hex string Expressions in default arguments are evaluated
id(obj) Return unique (run-time) when the function is defined, not when it’s
identifier for an object called. Changes to mutable default
# <--arguments
mutable
int(x) Convert from float/string survive between function calls.
isinstance(o, c) Eg. isinstance(2.1, float) def nasty(value=[]): arg
len(x) Number of items in x; x is
string,
tuple, list, dict print (nasty ()) # --> ['a']
list(iterable) Make a list print (nasty ()) # --> ['a', 'a']
long(x) Convert a string or number to
a def better(val=None):
long integer val = [] if val is None else val
value.append('a')
map(fn, iterable) Apply fn() to every item in
return value
iterable; return results in a list
max(a,b) What it says on the tin
max(iterable) Lambda (inline expression) functions:
min(a,b) Ditto g = lambda x: x ** 2 # Note: no return
min(iterable) print(g(8)) # prints 64
mul = lambda a, b: a * b # two arguments
next(iterator) Get next item from an iter
mul(4, 5) == 4 * 5 # --> True
open(name[,mode]) Open a file object
ord(c) Opposite of chr(int) Note: only for expressions, not statements.
pow(x, y) Same as x ** y Lambdas are often used with the Python
print (objects) What it says on the tin functions filter(), map() and reduce().
# get only those numbers divisible by three
takes end arg (default \ div3 = filter(lambda x: x%3==0,range(1,101))
n)
and sep arg (default ' ') Typically, you can put a lambda function
anywhere you put a normal function call.
range(stop) integer list; stops <
range(start,stop) stop default start=0;
range(fr,to,step) default step=1 Closures
Applies the two argument Closures are functions that have inner functions
reduce(fn, iter)
fn(x, y) cumulatively to the with data fixed in the inner function by the
items of iter. lexical scope of the outer. They are useful for
repr(object) Printable representation of an avoiding hard constants. Wikipedia has a
object derivative function for changeable values of dx,
reversed(seq) Get a reversed iterator using a closure.
def derivative(f, dx):
round(n[,digits]) Round to number of digits
"""Return a function that approximates
after the decimal place
the derivative of f using an interval
of dx, whichLike
setattr(obj,n,v) obj.nbe
should = vappropriately
#name/value
sorted(iterable)
small. Get new sorted list
str(object)
""" Get a string for an object
sum(iterable)
def _function(x):Sum list of numbers
type(object) return (f(xGet the type
+ dx) of object
- f(x)) / dx
return _function
xrange() Like#from derivative(f,
range() but better: dx)

f_dash_x = derivative(lambda x: x*x,0.00001)

f_dash_x(5) # yields approx. 10 (ie. y'=2x)

Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 6
An iterable object Classes
The contents of an iterable object can be Python is an object-oriented language with a
selected one at a time. Such objects include the multiple inheritance class mechanism that
Python sequence types and classes with the encapsulates program code and data.
magic method iter (), which returns an
iterator. An iterable object will produce a fresh Methods and attributes
iterator with each call to iter(). Most objects have associated functions or
iterator = iter(iterable_object) “methods” that are called using dot syntax:
obj.method(arg)
Iterators Objects also often have attributes or values that
Objects with a next() (Python 2) or next () are directly accessed without using getters and
(Python 3) method, that: setters (most unlike Java or C++)
 returns the next value in the iteration instance = Example_Class()
 updates the internal note of the next value print (instance.attribute)
 raises a StopIteration exception when done
Note: with the loop for x in y: if y is not an Simple example
iterator; Python calls iter() to get one. With each import math
loop, it calls next() on the iterator until a class Point:
StopIteration exception. # static class variable, point count
x = iter('XY') # iterate a string by hand count = 0
print (next(x)) # --> X
print (next(x)) # --> Y def init (self, x, y):
print (next(x)) # --> StopIteration self.x = float(x)
self.y = float(y)
Generators Point.count += 1
Generator functions are resumable functions that
def str (self):
work like iterators. They can be more space or
return \
time efficient than iterating over a list, (especially '(x={}, y={})'.format(self.x,
a very large list), as they only produce items as self.y)
they are needed.
def fib(max=None): def to_polar(self):
""" generator for Fibonacci sequence""" r = math.sqrt(self.x**2 + self.y**2)
a, b = 0, 1 theta = math.atan2(self.y, self.x)
while max is None or b <= max: return(r, theta)
yield b #  yield is like return
a, b = b, a+b # static method – trivial example ...
def static_eg(n):
[i for i in fib(10)] #  [1, 1, 2, 3, 5, 8] print ('{}'.format(n))
Note: a return statement (or getting to the end of static_eg = staticmethod(static_eg)
the function) ends the iteration.
# Instantiate 9 points & get polar coords
Trap: a yield statement is not allowed in the try for x in range(-1, 2):
clause of a try/finally construct. for y in range(-1, 2):
p = Point(x, y)
Messaging the generator print (p) # uses str () method
def resetableCounter(max=None): print (p.to_polar())
j = 0 print (Point.count) # check static variable
while max is None or j <= max: Point.static_eg(9) # check static method
x = yield j #  x gets the sent arg
j = j+1 if x is None else x
The self
x = resetableCounter(10) Class methods have an extra argument over
print x.send(None) #  0 functions. Usually named 'self'; it is a reference to
print x.send(5) #  5 the instance. It is not used in the method call;
print x.send(None) #  6 and is provided by Python to the method. Self is
print x.send(11) #  StopIteration like 'this' in C++ & Java
Trap: must send None on first send() call
Public and private methods and variables
Generator expressions Python does not enforce the public v private
Generator expressions build generators, just like data distinction. By convention, variables and
building a list from a comprehension. You can methods that begin with an underscore should
turn a list comprehension into a generator be treated as private (unless you really know
expression simply by replacing the square what you are doing). Variables that begin with
brackets [] with parentheses (). double underscore are mangled by the compiler
[i for i in xrange(10)] # list comprehension (and hence more private).
list(i for i in xrange(10)) # generated list

Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 7
Inheritance Magic class methods (not a complete list)
class DerivedClass1(BaseClass): Magic methods (which begin and end with double
statements
underscore) add functionality to your classes
class DerivedClass2(module_name.BaseClass):
statements consistent with the broader language.
Magic method What it does
init (self,[...]) Constructor
Multiple inheritance
class DerivedClass(Base1, Base2, Base3): del (self) Destructor pre-garbage
statements collection
str (self) Human readable string
Decorators for
Technically, decorators are just functions (or class contents. Called
classes), that take a callable object as an by str(self)
argument, and return an analogous object with repr (self) Machine readable
the decoration. We will skip how to write them, unambiguous Python
and focus on using a couple of common built in string expression for
decorators. class contents. Called
by repr(self) Note:
Practically, decorators are syntactic sugar for str(self) will call repr
more readable code. The @wrapper is used to if
transform the existing code. For example, the str is not defined.
following two method definitions are semantically eq (self, other) Behaviour for ==
equivalent. ne (self, other) Behaviour for !=
def f(...): lt (self, other) Behaviour for <
... gt (self, other) Behaviour for >
f = staticmethod(f) le (self, other) Behaviour for <=
ge (self, other) Behaviour for >=
@staticmethod add (self, other) Behaviour for +
def f(...): sub (self, other) Behaviour for -
... mul (self, other) Behaviour for *
div (self, other) Behaviour for /
Getters and setters mod (self, other) Behaviour for %
Although class attributes can be directly pow (self, other) Behaviour for **
accessed, the property function creates a pos (self, other) Behaviour for unary +
property manager. neg (self, other) Behaviour for unary -
class Example: hash (self) Returns an int when
def init (self): hash() called. Allows
self._x = None class instance to be
put in a
def getx(self): dictionary
return self._x
len (self) Length of container
def setx(self, value):
self._x = value contains (self, i) Behaviour for in and not
def delx(self): in operators
del self._x missing (self, i) What to do when dict
x = property(getx, setx, delx,"Doc txt") key i is missing
copy (self) Shallow copy
Which can be rewritten with decorators as: constructor
class Example: deepcopy (self, Deep copy constructor
def init (self): memodict={})
self._x = None iter (self) Provide an iterator
nonzero (self) Called by bool(self)
@property index (self) Called by x[self]
def x(self): setattr (self, Called by
"""Doc txt: I'm the 'x' property.""" name, val) self.name = val
return self._x
getattribute (self, Called by self.name
name)
@x.setter
def x(self, value): getattr (self, Called when self.name
self._x = value name) does not exist
delattr (self, Called by
@x.deleter name) del self.name
def x(self): getitem (self, key) Called by self[key]
del self._x setitem (self, key, Called by
val) self[key] = val

Version 14 March 2015 - [Draft – Mark Graph – mark dot the dot graph at gmail dot com – @Mark_Graph on twitter] 8