Numbers
Python's 2 main types for Numbers is int and oat
(or integers and oating point numbers)
type(1) # int
type(-10) # int
type(0) # int
type(0.0) # float
type(2.2) # float
type(4E2) # float - 4*10 to the power o
# Arithmetic
10 + 3 # 13
10 - 3 # 7
10 * 3 # 30
10 ** 3 # 1000
10 / 3 # 3.3333333333333335
10 // 3 # 3 --> floor division - no dec
10 % 3 # 1 --> modulo operator - retur
# Basic Functions
pow(5, 2) # 25 --> like doing 5**2
abs(-50) # 50
round(5.46) # 5
round(5.468, 2)# 5.47 --> round to nth
bin(512) # '0b1000000000' --> bi
hex(512) # '0x200' --> hexadecima
'*'*10 # **********
# Basic Functions
len('turtle') # 6
# Basic Methods
' I am alone '.strip() #
'On an island'.strip('d') #
'but life is good!'.split() #
'Help me'.replace('me', 'you') #
'Need to make fire'.startswith('Need')#
'and cook rice'.endswith('rice') #
'bye bye'.index('e') #
'still there?'.upper() #
'HELLO?!'.lower() #
'ok, I am done.'.capitalize() #
'oh hi there'.find('i') #
'oh hi there'.count('e') #
# String Formatting
name1 = 'Andrei'
name2 = 'Sunny'
print(f'Hello there {name1} and {name2}
print('Hello there {} and {}'.format(na
print('Hello there %s and %s' %(name1,
#Palindrome check
word = 'reviver'
p = bool(word.find(word[::-1]) + 1)
print(p) # True
Boolean
Boolean
True or False. Used in a lot of comparison and
logical operations in Python
bool(True)
bool(False)
# all of the below evaluate to False. E
print(bool(None))
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool([]))
print(bool({}))
print(bool(()))
print(bool(''))
print(bool(range(0)))
print(bool(set()))
# See Logical Operators and Comparison
Lists
Unlike strings, lists are mutable sequences in
python
my_list = [1, 2, '3', True]# We assume
len(my_list) # 4
my_list.index('3') # 2
my_list.count(2) # 1 --> coun
my_list[3] # True
my_list[1:] # [2, '3', T
my_list[:1] # [1]
my_list[-1] # True
my_list[::1] # [1, 2, '3'
my_list[::-1] # [True, '3'
my_list[0:3:2] # [1, '3']
# : is called slicing and has the forma
# Add to List
my_list * 2 # [1, 2, '3'
my_list + [100] # [1, 2, '3'
my_list.append(100) # None --> M
my_list.extend([100, 200]) # None --> M
my_list.insert(2, '!!!') # None -->
' '.join(['Hello','There'])# 'Hello The
# Copy a List
basket = ['apples', 'pears', 'oranges']
new_basket = basket.copy()
new_basket2 = basket[:]
# Remove from List
[1,2,3].pop() # 3 --> mutates origin
[1,2,3].pop(1) # 2 --> mutates origin
[1,2,3].remove(2)# None --> [1,3] Remov
[1,2,3].clear() # None --> mutates ori
del [1,2,3][0] #
# Ordering
# Ordering
[1,2,5,3].sort() # None --> Mut
[1,2,5,3].sort(reverse=True) # None -->
[1,2,5,3].reverse() # None --> Mut
sorted([1,2,5,3]) # [1, 2, 3, 5]
list(reversed([1,2,5,3]))# [3, 5, 2, 1]
# Useful operations
1 in [1,2,5,3] # True
min([1,2,3,4,5])# 1
max([1,2,3,4,5])# 5
sum([1,2,3,4,5])# 15
# Get First and Last element of a list
mList = [63, 21, 30, 14, 35, 26, 77, 18
first, *x, last = mList
print(first) #63
print(last) #10
# Matrix
matrix = [[1,2,3], [4,5,6], [7,8,9]]
matrix[2][0] # 7 --> Grab first first o
# Looping through a matrix by rows:
mx = [[1,2,3],[4,5,6]]
for row in range(len(mx)):
for col in range(len(mx[0])):
print(mx[row][col]) # 1 2 3 4 5
# Transform into a list:
[mx[row][col] for row in range(len(mx))
# Combine columns with zip and *:
[x for x in zip(*mx)] # [(1, 3), (2, 4)
# List Comprehensions
# new_list[<action> for <item> in <iter
a = [i for i in 'hello']
b = [i*2 for i in [1,2,3]]
c = [i for i in range(0,10) if i % 2 ==
# Advanced Functions
list_of_chars = list('Helloooo')
sum_of_elements = sum([1,2,3,4,5])
element_sum = [sum(pair) for pair in zi
sorted_by_second = sorted(['hi','you','
sorted_by_key = sorted([
{'name': 'Bina',
{'name':'Andy',
{'name': 'Zoey',
key=lambda el: (
# Read line of a file into a list
with open("myfile.txt") as f:
lines = [line.strip() for line in f]
Dictionaries
Also known as mappings or hash tables. They are
key value pairs that are guaranteed to retain
order of insertion starting from Python 3.7
g y
my_dict = {'name': 'Andrei Neagoie', 'a
my_dict['name'] #
len(my_dict) #
list(my_dict.keys()) #
list(my_dict.values()) #
list(my_dict.items()) #
my_dict['favourite_snack'] = 'Grapes'#
my_dict.get('age') #
my_dict.get('ages', 0 ) #
#Remove key
del my_dict['name']
my_dict.pop('name', None)
my_dict.update({'cool': True})
{**my_dict, **{'cool': True} }
new_dict = dict([['name','Andrei'],['ag
new_dict = dict(zip(['name','age','magi
new_dict = my_dict.pop('favourite_snack
# Dictionary Comprehension
{key: value for key, value in new_dict.
Tuples
Like lists, but they are used for immutable things
(that don't change)
my_tuple = ('apple','grapes','mango', '
apple, grapes, mango, grapes = my_tuple
len(my_tuple)
my_tuple[2]
my_tuple[-1]
# Immutability
my_tuple[1] = 'donuts' # TypeError
my_tuple.append('candy')# AttributeErro
# Methods
my_tuple.index('grapes') # 1
my_tuple.count('grapes') # 2
# Zip
list(zip([1,2,3], [4,5,6])) # [(1, 4),
# unzip
z = [(1, 2), (3, 4), (5, 6), (7, 8)] #
unzip = lambda z: list(zip(*z))
unzip(z)
Sets
Unordered collection of unique elements.
my_set = set()
my_set.add(1) # {1}
my_set.add(100)# {1, 100}
my_set.add(100)# {1, 100} --> no duplic
new_list = [1,2,3,3,3,4,4,5,6,1]
set(new_list) # {1, 2, 3, 4,
my_set.remove(100) # {1} --> Raise
my_set.discard(100) # {1} --> Doesn
my_set.clear() # {}
new_set = {1,2,3}.copy()# {1,2,3}
set1 = {1,2,3}
set2 = {3,4,5}
set3 = set1.union(set2) #
set4 = set1.intersection(set2) #
set5 = set1.difference(set2) #
set6 = set1.symmetric_difference(set2)#
set1.issubset(set2) #
set1.issuperset(set2) #
set1.isdisjoint(set2) #
# Frozenset
# hashable --> it can be used as a key
<frozenset> = frozenset(<collection>)
None
None is used for absence of a value and can be
used to show nothing has been assigned to an
object
type(None) # NoneType
a = None
Comparison Operators
== # equal values
!= # not equal
> # left operand is
< # left operand is
>= # left operand is
<= # left operand is
<element> is <element> # check if two o
Logical Operators
1 < 2 and 4 > 1 # True
1 > 3 or 4 > 1 # True
1 is not 4 # True
not True # False
1 not in [2,3,4]# True
if <condition that evaluates to boolean
# perform action1
elif <condition that evaluates to boole
# perform action2
else:
# perform action3
Loops
my_list = [1,2,3]
my_tuple = (1,2,3)
my_list2 = [(1,2), (3,4), (5,6)]
my_dict = {'a': 1, 'b': 2. 'c': 3}
for num in my_list:
print(num) # 1, 2, 3
for num in my_tuple:
print(num) # 1, 2, 3
for num in my_list2:
print(num) # (1,2), (3,4), (5,6)
for num in '123':
print(num) # 1, 2, 3
for k,v in my_dict.items(): # Dictionar
print(k) # 'a', 'b', 'c'
print(v) # 1, 2, 3
while <condition that evaluates to bool
# action
if <condition that evaluates to boole
break # break out of while loop
if <condition that evaluates to boole
continue # continue to the next lin
# waiting until user quits
msg = ''
while msg != 'quit':
msg = input("What should I do?")
print(msg)
Range
range(10) # range(0, 10) --> 0
range(1,10) # range(1, 10)
list(range(0,10,2))# [0, 2, 4, 6, 8]
Enumerate
for i, el in enumerate('helloo'):
print(f'{i}, {el}')
# 0, h
# 1, e
# 2, l
# 3, l
# 4, o
# 5, o
Counter
from collections import Counter
colors = ['red', 'blue', 'yellow', 'blu
counter = Counter(colors)# Counter({'bl
counter.most_common()[0] # ('blue', 3)
Named Tuple
Tuple is an immutable and hashable list.
Named tuple is its subclass with named
elements.
from collections import namedtuple
Point = namedtuple('Point', 'x y')
p = Point(1, y=2)# Point(x=1, y=2)
p[0] # 1
p.x # 1
getattr(p, 'y') # 2
p._fields # Or: Point._fields #(
from collections import namedtuple
Person = namedtuple('Person', 'name hei
person = Person('Jean-Luc', 187)
f'{person.height}' # '187'
'{p.height}'.format(p=person)# '187'
OrderedDict
Maintains order of insertion
from collections import OrderedDict
# Store each person's languages, keepin
programmers = OrderedDict()
programmers['Tim'] = ['python', 'javasc
programmers['Sarah'] = ['C++']
programmers['Bia'] = ['Ruby', 'Python',
for name, langs in programmers.items():
print(name + '-->')
for lang in langs:
print('\t' + lang)
Functions
*args and **kwargs
Splat (*) expands a collection into positional
arguments, while splatty-splat (**) expands a
dictionary into keyword arguments.
args = (1, 2)
kwargs = {'x': 3, 'y': 4, 'z': 5}
some_func(*args, **kwargs) # same as so
* Inside Function De nition
Splat combines zero or more positional
p p
arguments into a tuple, while splatty-splat
combines zero or more keyword arguments into a
dictionary.
def add(*a):
return sum(a)
add(1, 2, 3) # 6
Ordering of parameters:
def f(*args): # f(1, 2
def f(x, *args): # f(1, 2
def f(*args, z): # f(1, 2
def f(x, *args, z): # f(1, 2
def f(**kwargs): # f(x=1,
def f(x, **kwargs): # f(x=1,
def f(*args, **kwargs): # f(x=1,
def f(x, *args, **kwargs): # f(x=1,
def f(*args, y, **kwargs): # f(x=1,
def f(x, *args, z, **kwargs): # f(x=1,
Other Uses of *
[*[1,2,3], *[4]] # [1, 2
{*[1,2,3], *[4]} # {1, 2
(*[1,2,3], *[4]) # (1, 2
{**{'a': 1, 'b': 2}, **{'c': 3}}# {'a':
head *bod tail [1 2 3 4 5]
head, *body, tail = [1,2,3,4,5]
Lambda
# lambda: <return_value>
# lambda <argument1>, <argument2>: <ret
# Factorial
from functools import reduce
n = 3
factorial = reduce(lambda x, y: x*y, ra
print(factorial) #6
# Fibonacci
fib = lambda n : n if n <= 1 else fib(n
result = fib(10)
print(result) #55
Comprehensions
<list> = [i+1 for i in range(10)]
<set> = {i for i in range(10) if i > 5
<iter> = (i+5 for i in range(10))
<dict> = {i: i*2 for i in range(10)}
output = [i+j for i in range(3) for j i
# Is the same as:
output = []
for i in range(3):
for j in range(3):
output.append(i+j)
Ternary Condition
# <expression_if_true> if <condition> e
[a if a else 'zero' for a in [0, 1, 0,
Map Filter Reduce
from functools import reduce
list(map(lambda x: x + 1, range(10)))
list(filter(lambda x: x > 5, range(10))
reduce(lambda acc, x: acc + x, range(10
Any All
any([False, True, False])# True if at l
all([True,1,3,True]) # True if all
Closures
We have a closure in Python when:
A nested function references a value of its
enclosing function and then
the enclosing function returns the nested
function.
def get_multiplier(a):
def out(b):
return a * b
return out
>>> multiply_by_3 = get_multiplier(3)
>>> multiply_by_3(10)
30
If multiple nested functions within enclosing
function reference the same value, that value
gets shared.
To dynamically access function's rst free
o dy a ca y access u ct o s st ee
variable use
'<function>.__closure__[0].cell_contents' .
Scope
**If variable is being assigned to anywhere in the scope, it is
regarded as a local variable, unless it is declared as a 'global' or
a 'nonlocal'.**
def get_counter():
i = 0
def out():
nonlocal i
i += 1
return i
return out
>>> counter = get_counter()
>>> counter(), counter(), counter()
(1, 2, 3)
Modules
if __name__ == '__main__': # Runs main(
main()
import <module_name>
from <module_name> import <function_nam
import <module_name> as m
from <module_name> import <function_nam
from <module_name> import *
Iterators
In this cheatsheet '<collection>' can also
mean an iterator.
<iter> = iter(<collection>)
<iter> = iter(<function>, to_exclusive)
<el> = next(<iter> [, default])
Generators
Convenient way to implement the iterator
protocol.
def count(start, step):
while True:
yield start
start += step
>>> counter = count(10, 2)
>>> next(counter), next(counter), next(
(10, 12, 14)
Decorators
A decorator takes a function, adds some
functionality and returns it.
@decorator_name
def function_that_gets_passed_to_decora
...
Debugger Example
**Decorator that prints function's name every time it gets
called.**
from functools import wraps
def debug(func):
@wraps(func)
def out(*args, **kwargs):
print(func.__name__)
return func(*args, **kwargs)
return out
@debug
def add(x, y):
return x + y
Wraps is a helper decorator that copies
metadata of function add() to function out().
Without it 'add.__name__' would return
'out' .
Class
User de ned objects are created using the class
keyword
class <name>:
age = 80 # Class Object Attribute
def __init__(self, a):
self.a = a # Object Attribute
@classmethod
def get_class_name(cls):
return cls.__name__
Inheritance
```python class Person: def __init__(self, name, age): self.name =
name self.age = age
class Employee(Person): def init(self, name, age,
p y ( ) ( g
staff_num): super().init(name, age) self.staff_num
= staff_num
<h2 id="multiple-inheritance">Multiple
```python
class A: pass
class B: pass
class C(A, B): pass
MRO determines the order in which parent
classes are traversed when searching for a
method:
>>> C.mro()
[<class 'C'>, <class 'A'>, <class 'B'>,
Exceptions
try:
5/0
except ZeroDivisionError:
print("No division by zero!")
while True:
try:
x = int(input('Enter your age: '))
except ValueError:
print('Oops! That was no valid num
else: # code that depends on the try
print('Carry on!')
break
Raising Exception
```python raise ValueError('some error message') ```
Finally
```python try: raise KeyboardInterrupt except: print('oops')
nally: print('All done!')
<h2 id="command-line-arguments">Command
```python
import sys
script_name = sys.argv[0]
arguments = sys.argv[1:]
File IO
Opens a le and returns a corresponding le
p p g
object.
<file> = open('<path>', mode='r', encod
Modes
'r' - Read (default).
'w' - Write (truncate).
'x' - Write or fail if the le already exists.
'a' - Append.
'w+' - Read and write (truncate).
'r+' - Read and write from the start.
'a+' - Read and write from the end.
't' - Text mode (default).
'b' - Binary mode.
File
<file>.seek(0) # M
<str/bytes> = <file>.readline() # R
<list> = <file>.readlines() # R
<file>.write(<str/bytes>) # W
<file>.writelines(<list>) # W
Methods do not add or strip trailing newlines.
Read Text from File
def read_file(filename):
with open(filename, encoding='utf-8
return file.readlines() # or re
for line in read_file(filename):
print(line)
Write Text to File
def write_to_file(filename, text):
with open(filename, 'w', encoding='
file.write(text)
Append Text to File
def append_to_file(filename, text):
with open(filename, 'a', encoding='
file.write(text)
Useful Libraries
CSV
import csv
Read Rows from CSV File
def read_csv_file(filename):
with open(filename, encoding='utf-8
return csv.reader(file, delimit
Write Rows to CSV File
def write_to_csv_file(filename, rows):
with open(filename, 'w', encoding='
writer = csv.writer(file, delim
writer.writerows(rows)
JSON
import json
<str> = json.dumps(<object>, ensure_
<object> = json.loads(<str>)
Read Object from JSON File
def read_json_file(filename):
with open(filename, encoding='utf-8
return json.load(file)
Write Object to JSON File
def write_to_json_file(filename, an_obj
with open(filename, 'w', encoding='
json.dump(an_object, file, ensu
Pickle
import pickle
<bytes> = pickle.dumps(<object>)
<object> = pickle.loads(<bytes>)
Read Object from File
def read_pickle_file(filename):
with open(filename, 'rb') as file:
return pickle.load(file)
Write Object to File
def write_to_pickle_file(filename, an_o
with open(filename, 'wb') as file:
pickle.dump(an_object, file)
Pro le
Pro le
Basic
from time import time
start_time = time() # Seconds since
...
duration = time() - start_time
Math
from math import e, pi
from math import cos, acos, sin, asin,
from math import log, log10, log2
from math import inf, nan, isinf, isnan
Statistics
from statistics import mean, median, va
Random
from random import random, randint, cho
random() # random float between 0 and 1
randint(0, 100) # random integer betwee
random_el = choice([1,2,3,4]) # select
shuffle([1,2,3,4]) # shuffles a list
Datetime
Datetime
Module 'datetime' provides 'date' <D> , 'time'
<T> , 'datetime' <DT> and 'timedelta' <TD>
classes. All are immutable and hashable.
Time and datetime can be 'aware' <a> ,
meaning they have de ned timezone, or
'naive' <n> , meaning they don't.
If object is naive it is presumed to be in
system's timezone.
from datetime import date, time, dateti
from dateutil.tz import UTC, tzlocal, g
Constructors
<D> = date(year, month, day)
<T> = time(hour=0, minute=0, second=0,
<DT> = datetime(year, month, day, hour=
<TD> = timedelta(days=0, seconds=0, mic
minutes=0, hours=0, we
Use '<D/DT>.weekday()' to get the day
of the week (Mon == 0).
'fold=1' means second pass in case of
time jumping back for one hour.
Now
Now
<D/DTn> = D/DT.today()
<DTn> = DT.utcnow()
<DTa> = DT.now(<tz>)
Timezone
<tz> = UTC
<tz> = tzlocal()
<tz> = gettz('<Cont.>/<City>')
<DTa> = <DT>.astimezone(<tz>)
<Ta/DTa> = <T/DT>.replace(tzinfo=<tz>)
Regex
import re
<str> = re.sub(<regex>, new, text, co
<list> = re.findall(<regex>, text)
<list> = re.split(<regex>, text, maxsp
<Match> = re.search(<regex>, text)
<Match> = re.match(<regex>, text)
Match Object
<str> = <Match>.group() # Whole mat
<str> = <Match>.group(1) # Part in f
<tuple> = <Match>.groups() # All brack
<int> = <Match>.start() # Start ind
<int> = <Match>.end() # Exclusive
Special Sequences
Expressions below hold true for strings that
contain only ASCII characters. Use capital letters
for negation.
'\d' == '[0-9]' # Digit
'\s' == '[ \t\n\r\f\v]' # Whitespace
'\w' == '[a-zA-Z0-9_]' # Alphanumeric
Credits
Inspired by: this repo
Quick The Company
Links Academy
About
Home Courses ZTM
Pricing Career Ambassador
Testimonials Paths Contact
Blog Career Us
