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