Python 3 Cheat Sheet

©2012-2015 - Laurent Pointal Mémento v2.0.6 License Creative Commons Attribution 4 Python 3 Cheat Sheet Base Types integer, float, boolean, string, bytes int 783 0 -192 0b010 0o642 0xF3 binary zero octal float 9.23 0.0 -1.7e-6 -6 ×10 bool True False str "One\nTwo" Multiline string: escaped new line """X\tY\tZ 1\t2\t3""" escaped ' escaped tab a…zA…Z_ followed by a…zA…Z_0…9 ◽ diacritics allowed but should be avoided ◽ language keywords forbidden ◽ lower/UPPER case discrimination a toto x7 y_max BigOne 8y and for Variables assignment = ☝ assignment ⇔ binding of a name with a value 1) evaluation of right side expression value 2) assignment in order with left side names x=1.2+8+sin(y) a=b=c=0 assignment to same value y,z,r=9.2,-7.6,0 multiple assignments a,b=b,a values swap a,*b=seq unpacking of sequence in *a,b=seq item and list and x+=3 increment ⇔ x=x+3 *= x-=2 /= decrement ⇔ x=x-2 %= x=None « undefined » constant value del x … remove name x negative index positive index -5 0 ◾ key containers, no a priori order, fast key access, each key is unique dictionary 0 -5 1 -4 set {"key1","key2"} 2 -3 3 -2 {} {1,9,3,0} set() frozenset immutable set empty Conversions type(expression) int("15") → 15 nd int("3f",16) → 63 can specify integer number base in 2 parameter int(15.56) → 15 truncate decimal part float("-11.24e8") → -1124000000.0 round(15.56,1)→ 15.6 rounding to 1 decimal (0 decimal → integer number) bool(x) False for null x, empty container x , None or False x ; True for other x str(x)→ "…" representation string of x for display (cf. formatting on the back) chr(64)→'@' ord('@')→64 code ↔ char repr(x)→ "…" literal representation string of x bytes([72,9,64]) → b'H\t@' list("abc") → ['a','b','c'] dict([(3,"three"),(1,"one")]) → {1:'one',3:'three'} set(["one","two"]) → {'one','two'} separator str and sequence of str → assembled str ':'.join(['toto','12','pswd']) → 'toto:12:pswd' str splitted on whitespaces → list of str "words with spaces".split() → ['words','with','spaces'] str splitted on separator str → list of str "1,4,8,2".split(",") → ['1','4','8','2'] sequence of one type → list of another type (via list comprehension) [int(x) for x in ('1','29','-3')] → [1,29,-3] for lists, tuples, strings, bytes… Items count -3 -2 -1 2 3 4 len(lst)→5 -4 1 dict(a=3,b=4,k="v") ☝ keys=hashable values (base types, immutables…) lst=[10, 20, 30, 40, 50] positive slice negative slice dict {"key":"value"} collection Identifiers for variables, functions, modules, classes… names "" b"" (key/value associations) {1:"one",3:"three",2:"two",3.14:"π"} ☝ immutables hexadecimal octal Container Types ["mot"] [] ("mot",) () ◾ ordered sequences, fast index access, repeatable values ["x",11,8.9] list [1,5,9] 11,"y",7.4 tuple (1,5,9) Non modifiable values (immutables) ☝ expression with only comas →tuple str bytes (ordered sequences of chars / bytes) 'I\'m' bytes b"toto\xfe\775" ☺ ☹ hexa Latest version on : https://perso.limsi.fr/pointal/python:memento 4 -1 5 ☝ index from 0 (here from 0 to 4) Access to sub-sequences via lst[start slice:end slice:step] Sequence Containers Indexing Individual access to items via lst[index] lst[0]→10 lst[-1]→50 ⇒ first one ⇒ last one lst[1]→20 lst[-2]→40 On mutable sequences (list), remove with del lst[3] and modify with assignment lst[4]=25 lst[:3]→[10,20,30] lst[:-1]→[10,20,30,40] lst[::-1]→[50,40,30,20,10] lst[1:3]→[20,30] lst[1:-1]→[20,30,40] lst[-3:-1]→[30,40] lst[3:]→[40,50] lst[::-2]→[50,30,10] lst[::2]→[10,30,50] lst[:]→[10,20,30,40,50] shallow copy of sequence Missing slice indication → from start / up to end. On mutable sequences (list), remove with del lst[3:5] and modify with assignment lst[1:4]=[15,25] -neously a or b logical or one or other or both ☝ pitfall : and and or return value of a or of b (under shortcut evaluation). ⇒ ensure that a and b are booleans. logical not True False True and False constants ☝ floating numbers… approximated values integer ÷ ÷ remainder @ → matrix × python3.5+numpy (1+5.3)*2→12.6 abs(-3.2)→3.2 round(3.57,1)→3.6 pow(4,3)→64.0 ☝ usual order of operations parent statement: statement block 1… ⁝ parent statement: statement block2… ⁝ next statement after block 1 not a Operators: + - * / // % ** ab Priority (…) × ÷ Statements Blocks indentation ! Boolean Logic Comparisons : < > <= >= == != (boolean results) ≤ ≥ = ≠ both simultalogical and a and b ☝ configure editor to insert 4 spaces in place of an indentation tab. Maths from math import sin,pi… angles in radians sin(pi/4)→0.707… cos(2*pi/3)→-0.4999… sqrt(81)→9.0 √ log(e**2)→2.0 ceil(12.5)→13 floor(12.5)→12 modules math, statistics, random, decimal, fractions, numpy, etc. (cf. doc) Modules/Names Imports from monmod import nom1,nom2 as fct module truc⇔file truc.py →direct access to names, renaming with as import monmod →access via monmod.nom1 … ☝ modules and packages searched in python path (cf sys.path) statement block executed only if a condition is true Conditional Statement yes if logical condition: statements block ? no yes ? no Can go with several elif, elif... and only one final else. Only the block of first true condition is executed. if age<=18: state="Kid" elif age>65: state="Retired" ☝ with a var x: else: if bool(x)==True: ⇔ if x: state="Active" if bool(x)==False: ⇔ if not x: Signaling an error: raise ExcClass(…) Errors processing: try: normal procesising block except Exception as e: error processing block Exceptions on Errors normal raise X() processing error processing errorraise processing ☝ finally block for final processing in all cases. yes ? Loop Control break immediate exit continue next iteration no s = 0 initializations before the loop i = 1 condition with a least one variable value (here i) while i <= 100: s = s + i**2 i = i + 1 print("sum:",s) ☝ else block for normal loop exit. Algo: i=100 s= ∑ i 2 ☝ make condition variable change ! i=1 print("v=",3,"cm :",x,",",y+4) Display Input s = input("Instructions:") ☝ input always returns a string, convert it to required type (cf. boxed Conversions on the other side). len(c)→ items count Generic Operations on Containers min(c) max(c) sum(c) Note: For dictionaries and sets, these sorted(c)→ list sorted copy operations use keys. val in c → boolean, membership operator in (absence not in) enumerate(c)→ iterator on (index, value) zip(c1,c2…)→ iterator on tuples containing ci items at same index all(c)→ True if all c items evaluated to true, else False any(c)→ True if at least one item of c evaluated true, else False Specific to ordered sequences containers (lists, tuples, strings, bytes…) reversed(c)→ inversed iterator c*5→ duplicate c+c2→ concatenate c.index(val)→ position c.count(val)→ events count import copy copy.copy(c)→ shallow copy of container copy.deepcopy(c)→ deep copy of container Operations on Lists lst.append(val) add item at end lst.extend(seq) add sequence of items at end lst.insert(idx,val) insert item at index lst.remove(val) remove first item with value val lst.pop([idx])→value remove & return item at index idx (default last) lst.sort() lst.reverse() sort / reverse liste in place ☝ modify original list d.setdefault(key[,default])→value Operations on Sets Operators: | → union (vertical bar char) & → intersection - ^ → difference/symmetric diff. < <= > >= → inclusion relations Operators also exist as methods. s.update(s2) s.copy() s.add(key) s.remove(key) s.discard(key) s.clear() s.pop() Files storing data on disk, and reading it back f = open("file.txt","w",encoding="utf8") file variable for operations name of file on disk (+path…) opening mode ◽ 'r' read ◽ 'w' write ◽ 'a' append cf. modules os, os.path and pathlib ◽ …'+' 'x' 'b' 't' encoding of chars for text files: utf8 ascii latin1 … writing ☝ read empty string if end of file f.write("coucou") f.read([n]) → next chars reading if n not specified, read up to end ! f.readlines([n]) → list of next lines f.readline() → next line ☝ text mode t by default (read/write str), possible binary mode b (read/write bytes). Convert from/to required type ! f.close() ☝ dont forget to close the file after use ! f.truncate([size]) resize write cache f.flush() reading/writing progress sequentially in the file, modifiable with: f.writelines(list of lines) f.tell()→position Iterative Loop Statement next for var in sequence: statements block … finish Go over sequence's values s = "Some text" initializations before the loop cnt = 0 loop variable, assignment managed by for statement for c in s: Algo: count if c == "e": number of e cnt = cnt + 1 print("found",cnt,"'e'") in the string. loop on dict/set ⇔ loop on keys sequences use slices to loop on a subset of a sequence Go over sequence's index ◽ modify item at index ◽ access items around index (before / after) items to display : literal values, variables, expressions print options: ◽ sep=" " items separator, default space ◽ end="\n" end of print, default new line ◽ file=sys.stdout print to file, default standard output Operations on Dictionaries d.clear() d[key]=value del d[key] d[key]→ value d.update(d2) update/add associations d.keys() d.values() →iterable views on d.items() keys/values/associations d.pop(key[,default])→ value d.popitem()→ (key,value) d.get(key[,default])→ value statements block executed for each item of a container or iterator f.seek(position[,origin]) Very common: opening with a guarded block with open(…) as f: (automatic closing) and reading loop on lines for line in f : of a text file: # processing ofline lst = [11,18,9,12,23,4,17] lost = [] Algo: limit values greater for idx in range(len(lst)): than 15, memorizing val = lst[idx] of lost values. if val > 15: lost.append(val) lst[idx] = 15 print("modif:",lst,"-lost:",lost) ☝ good habit : don't modify loop variable while logical condition: statements block Conditional Loop Statement Go simultaneously over sequence's index and values: for idx,val in enumerate(lst): range([start,] end [,step]) Integer Sequences ☝ start default 0, end not included in sequence, step signed, default 1 range(5)→ 0 1 2 3 4 range(2,12,3)→ 2 5 8 11 range(3,8)→ 3 4 5 6 7 range(20,5,-5)→ 20 15 10 range(len(seq))→ sequence of index of values in seq ☝ range provides an immutable sequence of int constructed as needed Function Definition function name (identifier) named parameters def fct(x,y,z): fct """documentation""" # statements block, res computation, etc. result value of the call, if no computed return res result to return: return None ☝ parameters and all variables of this block exist only in the block and during the function call (think of a “black box”) Advanced: def fct(x,y,z,*args,a=3,b=5,**kwargs): *args variable positional arguments (→tuple), default values, **kwargs variable named arguments (→dict) Function Call r = fct(3,i+2,2*i) storage/use of returned value one argument per parameter ☝ this is the use of function name with parentheses which does the call Advanced: *sequence **dict fct() fct Operations on Strings s.startswith(prefix[,start[,end]]) s.endswith(suffix[,start[,end]]) s.strip([chars]) s.count(sub[,start[,end]]) s.partition(sep)→ (before,sep,after) s.index(sub[,start[,end]]) s.find(sub[,start[,end]]) s.is…() tests on chars categories (ex. s.isalpha()) s.upper() s.lower() s.title() s.swapcase() s.casefold() s.capitalize() s.center([width,fill]) s.ljust([width,fill]) s.rjust([width,fill]) s.zfill([width]) s.encode(encoding) s.split([sep]) s.join(seq) formating directives values to format "modele{} {} {}".format(x,y,r) "{selection:formatting!conversion}" Formatting str ◽ Selection : "{:+2.3f}".format(45.72793) 2 →'+45.728' nom "{1:>10s}".format(8,"toto") 0.nom →' toto' 4[key] "{x!r}".format(x="I'm") 0[2] →'"I\'m"' ◽ Formatting : fill char alignment sign mini width.precision~maxwidth type Examples ☝ beware of infinite loops! statements block executed as long as condition is true <>^= 0 at start for filling with 0 + - space integer: b binary, c char, d decimal (default), o octal, x or X hexa… float: e or E exponential, f or F fixed point, g or G appropriate (default), string: s … % percent ◽ Conversion : s (readable text) or r (literal representation)