Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/aneagoie/ztm-python-cheat-sheet
https://github.com/aneagoie/ztm-python-cheat-sheet
Last synced: 10 days ago
JSON representation
- Host: GitHub
- URL: https://github.com/aneagoie/ztm-python-cheat-sheet
- Owner: aneagoie
- Created: 2019-09-21T23:51:14.000Z (about 5 years ago)
- Default Branch: master
- Last Pushed: 2024-05-01T20:44:25.000Z (8 months ago)
- Last Synced: 2024-10-16T02:45:34.077Z (about 2 months ago)
- Homepage: https://zerotomastery.io/courses/python/cheatsheet/
- Size: 66.4 KB
- Stars: 2,437
- Watchers: 187
- Forks: 1,347
- Open Issues: 7
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- jimsghstars - aneagoie/ztm-python-cheat-sheet - (Others)
README
Python ZTM Cheatsheet 💻🚀
===============================
We created this Python 3 Cheat Sheet initially for students of [Complete Python Developer: Zero to Mastery](https://zerotomastery.io/courses/learn-python/) but we're now sharing it with any Python beginners to help them learn and remember common Python syntax and with intermediate and advanced Python developers as a handy reference. If you'd like to download a PDF version of this Python Cheat Sheet, you can get it [here](https://zerotomastery.io/courses/python/cheatsheet/?utm_source=github&utm_medium=ztm-python-cheat-sheet)!
Contents
--------
**Python Types:** **[`Numbers`](#numbers)__,__[`Strings`](#strings)__,__[`Boolean`](#boolean)__,__[`Lists`](#lists)__,__[`Dictionaries`](#dictionaries)__,__ [`Tuples`](#tuples)__,__[`Sets`](#sets)__,__[`None`](#none)**
**Python Basics:** **[`Comparison Operators`](#comparison-operators)__,__[`Logical Operators`](#logical-operators)__,__[`Loops`](#loops)__,__[`Range`](#range)__,__[`Enumerate`](#enumerate)__,__[`Counter`](#counter)__,__[`Named Tuple`](#named-tuple)__,__[`OrderedDict`](#ordereddict)**
**Functions:** **[`Functions`](#functions)__,__[`Lambda`](#lambda)__,__[`Comprehensions`](#comprehensions)__,__[`Map,Filter,Reduce`](#map-filter-reduce)__,__[`Ternary`](#ternary-condition)__,__[`Any,All`](#any-all)__,__[`Closures`](#closures)__,__[`Scope`](#scope)**
**Advanced Python:** **[`Modules`](#modules)__,__[`Iterators`](#iterators)__,__[`Generators`](#generators)__,__[`Decorators`](#decorators)__,__[`Class`](#class)__,__[`Exceptions`](#exceptions)__,__[`Command Line Arguments`](#command-line-arguments)__,__[`File IO`](#file-io)__,__[`Useful Libraries`](#useful-libraries)**
Numbers
----
**python's 2 main types for Numbers is int and float (or integers and floating point numbers)**
```python
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 of 2
```
```python
# Arithmetic
10 + 3 # 13
10 - 3 # 7
10 * 3 # 30
10 ** 3 # 1000
10 / 3 # 3.3333333333333335
10 // 3 # 3 --> floor division - no decimals and returns an int
10 % 3 # 1 --> modulo operator - return the remainder. Good for deciding if number is even or odd
```
```python
# 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 digit
bin(512) # '0b1000000000' --> binary format
hex(512) # '0x200' --> hexadecimal format
```
```python
# Converting Strings to Numbers
age = input("How old are you?")
age = int(age)
pi = input("What is the value of pi?")
pi = float(pi)
```
Strings
----
**strings in python are stored as sequences of letters in memory**
```python
type('Hellloooooo') # str
'I\'m thirsty'
"I'm thirsty"
"\n" # new line
"\t" # adds a tab
'Hey you!'[4] # y
name = 'Andrei Neagoie'
name[4] # e
name[:] # Andrei Neagoie
name[1:] # ndrei Neagoie
name[:1] # A
name[-1] # e
name[::1] # Andrei Neagoie
name[::-1] # eiogaeN ierdnA
name[0:10:2]# Ade e
# : is called slicing and has the format [ start : end : step ]
'Hi there ' + 'Timmy' # 'Hi there Timmy' --> This is called string concatenation
'*'*10 # **********
```
```python
# Basic Functions
len('turtle') # 6
# Basic Methods
' I am alone '.strip() # 'I am alone' --> Strips all whitespace characters from both ends.
'On an island'.strip('d') # 'On an islan' --> # Strips all passed characters from both ends.
'but life is good!'.split() # ['but', 'life', 'is', 'good!']
'Help me'.replace('me', 'you') # 'Help you' --> Replaces first with second param
'Need to make fire'.startswith('Need')# True
'and cook rice'.endswith('rice') # True
'still there?'.upper() # STILL THERE?
'HELLO?!'.lower() # hello?!
'ok, I am done.'.capitalize() # 'Ok, I am done.'
'oh hi there'.count('e') # 2
'bye bye'.index('e') # 2
'oh hi there'.find('i') # 4 --> returns the starting index position of the first occurrence
'oh hi there'.find('a') # -1
'oh hi there'.index('a') # Raises ValueError
```
```python
# String Formatting
name1 = 'Andrei'
name2 = 'Sunny'
print(f'Hello there {name1} and {name2}') # Hello there Andrei and Sunny - Newer way to do things as of python 3.6
print('Hello there {} and {}'.format(name1, name2))# Hello there Andrei and Sunny
print('Hello there %s and %s' %(name1, name2)) # Hello there Andrei and Sunny --> you can also use %d, %f, %r for integers, floats, string representations of objects respectively
```
```python
# Palindrome check
word = 'reviver'
p = bool(word.find(word[::-1]) + 1)
print(p) # True
```
Boolean
----
**True or False. Used in a lot of comparison and logical operations in Python**
```python
bool(True)
bool(False)
# all of the below evaluate to False. Everything else will evaluate to True in Python.
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 Operators section for more on booleans.
```
Lists
----
**Unlike strings, lists are mutable sequences in python**
```python
my_list = [1, 2, '3', True]# We assume this list won't mutate for each example below
len(my_list) # 4
my_list.index('3') # 2
my_list.count(2) # 1 --> count how many times 2 appears
my_list[3] # True
my_list[1:] # [2, '3', True]
my_list[:1] # [1]
my_list[-1] # True
my_list[::1] # [1, 2, '3', True]
my_list[::-1] # [True, '3', 2, 1]
my_list[0:3:2] # [1, '3']
# : is called slicing and has the format [ start : end : step ]
```
```python
# Add to List
my_list * 2 # [1, 2, '3', True, 1, 2, '3', True]
my_list + [100] # [1, 2, '3', True, 100] --> doesn't mutate original list, creates new one
my_list.append(100) # None --> Mutates original list to [1, 2, '3', True, 100] # Or: += []
my_list.extend([100, 200]) # None --> Mutates original list to [1, 2, '3', True, 100, 200]
my_list.insert(2, '!!!') # None --> [1, 2, '!!!', '3', True] - Inserts item at index and moves the rest to the right.
' '.join(['Hello','There'])# 'Hello There' --> Joins elements using string as separator.
```
```python
# Copy a List
basket = ['apples', 'pears', 'oranges']
new_basket = basket.copy()
new_basket2 = basket[:]
```
```python
# Remove from List
[1,2,3].pop() # 3 --> mutates original list, default index in the pop method is -1 (the last item)
[1,2,3].pop(1) # 2 --> mutates original list
[1,2,3].remove(2)# None --> [1,3] Removes first occurrence of item or raises ValueError.
[1,2,3].clear() # None --> mutates original list and removes all items: []
del [1,2,3][0] # None --> removes item on index 0 or raises IndexError
```
```python
# Ordering
[1,2,5,3].sort() # None --> Mutates list to [1, 2, 3, 5]
[1,2,5,3].sort(reverse=True) # None --> Mutates list to [5, 3, 2, 1]
[1,2,5,3].reverse() # None --> Mutates list to [3, 5, 2, 1]
sorted([1,2,5,3]) # [1, 2, 3, 5] --> new list created
my_list = [(4,1),(2,4),(2,5),(1,6),(8,9)]
sorted(my_list,key=lambda x: int(x[0])) # [(1, 6), (2, 4), (2, 5), (4, 1), (8, 9)] --> sort the list by 1st (0th index) value of the tuple
list(reversed([1,2,5,3]))# [3, 5, 2, 1] --> reversed() returns an iterator
```
```python
# 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
```
```python
# Get First and Last element of a list
mList = [63, 21, 30, 14, 35, 26, 77, 18, 49, 10]
first, *x, last = mList
print(first) #63
print(last) #10
```
```python
# Matrix
matrix = [[1,2,3], [4,5,6], [7,8,9]]
matrix[2][0] # 7 --> Grab first first of the third item in the matrix object
# 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 6
# Transform into a list:
[mx[row][col] for row in range(len(mx)) for col in range(len(mx[0]))] # [1,2,3,4,5,6]
# Combine columns with zip and *:
[x for x in zip(*mx)] # [(1, 3), (2, 4)]
```
```python
# List Comprehensions
# new_list[ for in if ]
a = [i for i in 'hello'] # ['h', 'e', 'l', 'l', '0']
b = [i*2 for i in [1,2,3]] # [2, 4, 6]
c = [i for i in range(0,10) if i % 2 == 0]# [0, 2, 4, 6, 8]
```
```python
# Advanced Functions
list_of_chars = list('Helloooo') # ['H', 'e', 'l', 'l', 'o', 'o', 'o', 'o']
sum_of_elements = sum([1,2,3,4,5]) # 15
element_sum = [sum(pair) for pair in zip([1,2,3],[4,5,6])] # [5, 7, 9]
sorted_by_second = sorted(['hi','you','man'], key=lambda el: el[1])# ['man', 'hi', 'you']
sorted_by_key = sorted([
{'name': 'Bina', 'age': 30},
{'name':'Andy', 'age': 18},
{'name': 'Zoey', 'age': 55}],
key=lambda el: (el['name']))# [{'name': 'Andy', 'age': 18}, {'name': 'Bina', 'age': 30}, {'name': 'Zoey', 'age': 55}]
```
```python
# 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**
```python
my_dict = {'name': 'Andrei Neagoie', 'age': 30, 'magic_power': False}
my_dict['name'] # Andrei Neagoie
len(my_dict) # 3
list(my_dict.keys()) # ['name', 'age', 'magic_power']
list(my_dict.values()) # ['Andrei Neagoie', 30, False]
list(my_dict.items()) # [('name', 'Andrei Neagoie'), ('age', 30), ('magic_power', False)]
my_dict['favourite_snack'] = 'Grapes'# {'name': 'Andrei Neagoie', 'age': 30, 'magic_power': False, 'favourite_snack': 'Grapes'}
my_dict.get('age') # 30 --> Returns None if key does not exist.
my_dict.get('ages', 0 ) # 0 --> Returns default (2nd param) if key is not found
#Remove key
del my_dict['name']
my_dict.pop('name', None)
```
```python
my_dict.update({'cool': True}) # {'name': 'Andrei Neagoie', 'age': 30, 'magic_power': False, 'favourite_snack': 'Grapes', 'cool': True}
{**my_dict, **{'cool': True} } # {'name': 'Andrei Neagoie', 'age': 30, 'magic_power': False, 'favourite_snack': 'Grapes', 'cool': True}
new_dict = dict([['name','Andrei'],['age',32],['magic_power',False]]) # Creates a dict from collection of key-value pairs.
new_dict = dict(zip(['name','age','magic_power'],['Andrei',32, False]))# Creates a dict from two collections.
new_dict = my_dict.pop('favourite_snack') # Removes item from dictionary.
```
```python
# Dictionary Comprehension
{key: value for key, value in new_dict.items() if key == 'age' or key == 'name'} # {'name': 'Andrei', 'age': 32} --> Filter dict by keys
```
Tuples
----
**Like lists, but they are used for immutable thing (that don't change)**
```python
my_tuple = ('apple','grapes','mango', 'grapes')
apple, grapes, mango, grapes = my_tuple# Tuple unpacking
len(my_tuple) # 4
my_tuple[2] # mango
my_tuple[-1] # 'grapes'
```
```python
# Immutability
my_tuple[1] = 'donuts' # TypeError
my_tuple.append('candy')# AttributeError
```
```python
# Methods
my_tuple.index('grapes') # 1
my_tuple.count('grapes') # 2
```
```python
# Zip
list(zip([1,2,3], [4,5,6])) # [(1, 4), (2, 5), (3, 6)]
```
```python
# unzip
z = [(1, 2), (3, 4), (5, 6), (7, 8)] # Some output of zip() function
unzip = lambda z: list(zip(*z))
unzip(z)
```
Sets
---
**Unorderd collection of unique elements.**
```python
my_set = set()
my_set.add(1) # {1}
my_set.add(100)# {1, 100}
my_set.add(100)# {1, 100} --> no duplicates!
```
```python
new_list = [1,2,3,3,3,4,4,5,6,1]
set(new_list) # {1, 2, 3, 4, 5, 6}
my_set.remove(100) # {1} --> Raises KeyError if element not found
my_set.discard(100) # {1} --> Doesn't raise an error if element not found
my_set.clear() # {}
new_set = {1,2,3}.copy()# {1,2,3}
```
```python
set1 = {1,2,3}
set2 = {3,4,5}
set3 = set1.union(set2) # {1,2,3,4,5}
set4 = set1.intersection(set2) # {3}
set5 = set1.difference(set2) # {1, 2}
set6 = set1.symmetric_difference(set2)# {1, 2, 4, 5}
set1.issubset(set2) # False
set1.issuperset(set2) # False
set1.isdisjoint(set2) # False --> return True if two sets have a null intersection.
```
```python
# Frozenset
# hashable --> it can be used as a key in a dictionary or as an element in a set.
= frozenset()
```
None
----
**None is used for absence of a value and can be used to show nothing has been assigned to an object**
```python
type(None) # NoneType
a = None
```
Comparison Operators
--------
```python
== # equal values
!= # not equal
> # left operand is greater than right operand
< # left operand is less than right operand
>= # left operand is greater than or equal to right operand
<= # left operand is less than or equal to right operand
is # check if two operands refer to same object in memory
```
Logical Operators
--------
```python
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 :
# perform action1
elif :
# perform action2
else:
# perform action3
```
Loops
--------
```python
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 idx,value in enumerate(my_list):
print(idx) # get the index of the item
print(value) # get the value
for k,v in my_dict.items(): # Dictionary Unpacking
print(k) # 'a', 'b', 'c'
print(v) # 1, 2, 3
while :
# action
if :
break # break out of while loop
if :
continue # continue to the next line in the block
```
```python
# waiting until user quits
msg = ''
while msg != 'quit':
msg = input("What should I do?")
print(msg)
```
Range
-----
```python
range(10) # range(0, 10) --> 0 to 9
range(1,10) # range(1, 10)
list(range(0,10,2))# [0, 2, 4, 6, 8]
```
Enumerate
---------
```python
for i, el in enumerate('helloo'):
print(f'{i}, {el}')
# 0, h
# 1, e
# 2, l
# 3, l
# 4, o
# 5, o
```
Counter
-----
```python
from collections import Counter
colors = ['red', 'blue', 'yellow', 'blue', 'red', 'blue']
counter = Counter(colors)# Counter({'blue': 3, 'red': 2, 'yellow': 1})
counter.most_common()[0] # ('blue', 3)
```
Named Tuple
-----------
* **Tuple is an immutable and hashable list.**
* **Named tuple is its subclass with named elements.**
```python
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 #('x', 'y')
```
```python
from collections import namedtuple
Person = namedtuple('Person', 'name height')
person = Person('Jean-Luc', 187)
f'{person.height}' # '187'
'{p.height}'.format(p=person)# '187'
```
OrderedDict
--------
* **Maintains order of insertion**
```python
from collections import OrderedDict
# Store each person's languages, keeping # track of who responded first.
programmers = OrderedDict()
programmers['Tim'] = ['python', 'javascript']
programmers['Sarah'] = ['C++']
programmers['Bia'] = ['Ruby', 'Python', 'Go']
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.**
```python
args = (1, 2)
kwargs = {'x': 3, 'y': 4, 'z': 5}
some_func(*args, **kwargs) # same as some_func(1, 2, x=3, y=4, z=5)
```
#### \* Inside Function Definition
**Splat combines zero or more positional arguments into a tuple, while splatty-splat combines zero or more keyword arguments into a dictionary.**
```python
def add(*a):
return sum(a)
add(1, 2, 3) # 6
```
##### Ordering of parameters:
```python
def f(*args): # f(1, 2, 3)
def f(x, *args): # f(1, 2, 3)
def f(*args, z): # f(1, 2, z=3)
def f(x, *args, z): # f(1, 2, z=3)
def f(**kwargs): # f(x=1, y=2, z=3)
def f(x, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3)
def f(*args, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)
def f(x, *args, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)
def f(*args, y, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3)
def f(x, *args, z, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3)
```
#### Other Uses of \*
```python
[*[1,2,3], *[4]] # [1, 2, 3, 4]
{*[1,2,3], *[4]} # {1, 2, 3, 4}
(*[1,2,3], *[4]) # (1, 2, 3, 4)
{**{'a': 1, 'b': 2}, **{'c': 3}}# {'a': 1, 'b': 2, 'c': 3}
```
```python
head, *body, tail = [1,2,3,4,5]
```
Lambda
------
```python
# lambda:
# lambda , :
```
```python
# Factorial
from functools import reduce
n = 3
factorial = reduce(lambda x, y: x*y, range(1, n+1))
print(factorial) #6
```
```python
# Fibonacci
fib = lambda n : n if n <= 1 else fib(n-1) + fib(n-2)
result = fib(10)
print(result) #55
```
Comprehensions
------
```python
= [i+1 for i in range(10)] # [1, 2, ..., 10]
= {i for i in range(10) if i > 5} # {6, 7, 8, 9}
= (i+5 for i in range(10)) # (5, 6, ..., 14)
= {i: i*2 for i in range(10)} # {0: 0, 1: 2, ..., 9: 18}
```
```python
output = [i+j for i in range(3) for j in range(3)] # [0, 1, 2, 1, 2, 3, 2, 3, 4]
# Is the same as:
output = []
for i in range(3):
for j in range(3):
output.append(i+j)
```
Ternary Condition
-------
```python
# if else
[a if a else 'zero' for a in [0, 1, 0, 3]] # ['zero', 1, 'zero', 3]
```
Map Filter Reduce
------
```python
from functools import reduce
list(map(lambda x: x + 1, range(10))) # [1, 2, 3, 4, 5, 6, 7, 8, 9,10]
list(filter(lambda x: x > 5, range(10))) # (6, 7, 8, 9)
reduce(lambda acc, x: acc + x, range(10)) # 45
```
Any All
------
```python
any([False, True, False])# True if at least one item in collection is truthy, False if empty.
all([True,1,3,True]) # True if all items in collection are true
```
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.**
```python
def get_multiplier(a):
def out(b):
return a * b
return out
```
```python
>>> 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 first free variable use `'.__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'.**
```python
def get_counter():
i = 0
def out():
nonlocal i
i += 1
return i
return out
```
```python
>>> counter = get_counter()
>>> counter(), counter(), counter()
(1, 2, 3)
```
Modules
----
```python
if __name__ == '__main__': # Runs main() if file wasn't imported.
main()
```
```python
import
from import
import as m
from import as m_function
from import *
```
Iterators
--------
**In this cheatsheet `''` can also mean an iterator.**
```python
= iter()
= iter(, to_exclusive) # Sequence of return values until 'to_exclusive'.
= next( [, default]) # Raises StopIteration or returns 'default' on end.
```
Generators
---------
**Convenient way to implement the iterator protocol.**
```python
def count(start, step):
while True:
yield start
start += step
```
```python
>>> counter = count(10, 2)
>>> next(counter), next(counter), next(counter)
(10, 12, 14)
```
Decorators
---------
**A decorator takes a function, adds some functionality and returns it.**
```python
@decorator_name
def function_that_gets_passed_to_decorator():
...
```
**Example Decorator: timing performance using a decorator.**
* **The functools decorator `@functools.wraps` is used to maintain function naming and
documentation of the function within the decorator.**
```python
from time import time
import functools
def performance(func):
@functools.wraps()
def wrapper(*args, **kwargs):
t1 = time()
result = func(*args, **kwargs)
t2 = time()
print(f"Took: {t2 - t1} ms")
return result
return wrapper
# calling a function with the decorator
@performance
def long_time():
print(sum(i*i for i in range(10000)))
```
### Debugger Example
**Decorator that prints function's name every time it gets called.**
```python
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 defined objects are created using the class keyword**
```python
class :
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, staff_num):
super().__init__(name, age)
self.staff_num = staff_num
```
### Multiple Inheritance
```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:**
```python
>>> C.mro()
[, , , ]
```
Exceptions
----------
```python
try:
5/0
except ZeroDivisionError:
print("No division by zero!")
```
```python
while True:
try:
x = int(input('Enter your age: '))
except ValueError:
print('Oops! That was no valid number. Try again...')
else: # code that depends on the try block running successfully should be placed in the else block.
print('Carry on!')
break
```
### Raising Exception
```python
raise ValueError('some error message')
```
### Finally
```python
try:
raise KeyboardInterrupt
except:
print('oops')
finally:
print('All done!')
```
Command Line Arguments
----------------------
```python
import sys
script_name = sys.argv[0]
arguments = sys.argv[1:]
```
File IO
----
**Opens a file and returns a corresponding file object.**
```python
= open('', mode='r', encoding=None)
```
### Modes
* **`'r'` - Read (default).**
* **`'w'` - Write (truncate).**
* **`'x'` - Write or fail if the file 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
```python
.seek(0) # Moves to the start of the file.
```
```python
= .readline() # Returns a line.
= .readlines() # Returns a list of lines.
```
```python
.write() # Writes a string or bytes object.
.writelines() # Writes a list of strings or bytes objects.
```
* **Methods do not add or strip trailing newlines.**
### Read Text from File
```python
def read_file(filename):
with open(filename, encoding='utf-8') as file:
return file.readlines() # or read()
for line in read_file(filename):
print(line)
```
### Write Text to File
```python
def write_to_file(filename, text):
with open(filename, 'w', encoding='utf-8') as file:
file.write(text)
```
### Append Text to File
```python
def append_to_file(filename, text):
with open(filename, 'a', encoding='utf-8') as file:
file.write(text)
```
Useful Libraries
=========
CSV
---
```python
import csv
```
### Read Rows from CSV File
```python
def read_csv_file(filename):
with open(filename, encoding='utf-8') as file:
return csv.reader(file, delimiter=';')
```
### Write Rows to CSV File
```python
def write_to_csv_file(filename, rows):
with open(filename, 'w', encoding='utf-8') as file:
writer = csv.writer(file, delimiter=';')
writer.writerows(rows)
```
JSON
----
```python
import json
= json.dumps(, ensure_ascii=True, indent=None)
= json.loads()
```
### Read Object from JSON File
```python
def read_json_file(filename):
with open(filename, encoding='utf-8') as file:
return json.load(file)
```
### Write Object to JSON File
```python
def write_to_json_file(filename, an_object):
with open(filename, 'w', encoding='utf-8') as file:
json.dump(an_object, file, ensure_ascii=False, indent=2)
```
Pickle
------
```python
import pickle
= pickle.dumps()
= pickle.loads()
```
### Read Object from File
```python
def read_pickle_file(filename):
with open(filename, 'rb') as file:
return pickle.load(file)
```
### Write Object to File
```python
def write_to_pickle_file(filename, an_object):
with open(filename, 'wb') as file:
pickle.dump(an_object, file)
```
Profile
-------
### Basic
```python
from time import time
start_time = time() # Seconds since
...
duration = time() - start_time
```
### Math
```python
from math import e, pi
from math import cos, acos, sin, asin, tan, atan, degrees, radians
from math import log, log10, log2
from math import inf, nan, isinf, isnan
```
### Statistics
```python
from statistics import mean, median, variance, pvariance, pstdev
```
### Random
```python
from random import random, randint, choice, shuffle
random() # random float between 0 and 1
randint(0, 100) # random integer between 0 and 100
random_el = choice([1,2,3,4]) # select a random element from list
shuffle([1,2,3,4]) # shuffles a list
```
Datetime
--------
* **Module 'datetime' provides 'date' ``, 'time' ``, 'datetime' `
* **Time and datetime can be 'aware' ``, meaning they have defined timezone, or 'naive' ``, meaning they don't.**
* **If object is naive it is presumed to be in system's timezone.**
```python
from datetime import date, time, datetime, timedelta
from dateutil.tz import UTC, tzlocal, gettz
```
### Constructors
```python
= date(year, month, day)
= time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)
= timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,
minutes=0, hours=0, weeks=0)
```
* **Use `'.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
```python
= D/DT.today() # Current local date or naive datetime.
= DT.utcnow() # Naive datetime from current UTC time.
= DT.now() # Aware datetime from current tz time.
```
### Timezone
```python
= UTC # UTC timezone.
= tzlocal() # Local timezone.
= gettz('/') # Timezone from 'Continent/City_Name' str.
```
```python
=
= .replace(tzinfo=) # Unconverted object with new timezone.
```
Regex
-----
```python
import re
= re.sub(, new, text, count=0) # Substitutes all occurrences.
= re.findall(, text) # Returns all occurrences.
= re.split(, text, maxsplit=0) # Use brackets in regex to keep the matches.
= re.search(, text) # Searches for first occurrence of pattern.
= re.match(, text) # Searches only at the beginning of the text.
```
### Match Object
```python
= .group() # Whole match.
= .group(1) # Part in first bracket.
= .groups() # All bracketed parts.
= .start() # Start index of a match.
= .end() # Exclusive end index of a match.
```
### Special Sequences
**Expressions below hold true for strings that contain only ASCII characters. Use capital letters for negation.**
```python
'\d' == '[0-9]' # Digit
'\s' == '[ \t\n\r\f\v]' # Whitespace
'\w' == '[a-zA-Z0-9_]' # Alphanumeric
```
Credits
------
Inspired by: https://github.com/gto76/python-cheatsheet