@ -3,7 +3,7 @@ Python and Libraries Cheatsheet
Main
----
```
```python
if __name__ == '__main__':
main()
```
@ -11,7 +11,7 @@ if __name__ == '__main__':
List
----
```
```python
< list > [< inclusive from > :< exclusive to > :< step size > ]
< list > .extend(< list > )
< list > .sort()
@ -22,7 +22,7 @@ sorted_by_second = sorted(<list>, key=lambda tup: tup[1])
Dictionary
----------
```
```python
< dict > .items()
< dict > .get(< key > , < default > )
< dict > .setdefault(< key > , < default > )
@ -31,7 +31,7 @@ Dictionary
Set
---
```
```python
< set > = set()
< set > .add(< el > )
< set > .update(< set > )
@ -42,7 +42,7 @@ Set
Range
-----
```
```python
range(< to exclusive > )
range(< from inclusive > , < to exclusive > )
range(< from inclusive > , < to exclusive > , < step size > ) # Negative step for backward
@ -50,17 +50,17 @@ range(<from inclusive>, <to exclusive>, <step size>) # Negative step for backwa
Enumerate
---------
```
```python
for i, < el > in enumerate(< list > )
```
Type
----
```
```python
type(< el > ) is int/str/set/list
```
```
```python
import numbers
isinstance(< el > , numbers.Number)
```
@ -68,7 +68,7 @@ isinstance(<el>, numbers.Number)
String
------
```
```python
str.replace(< text > , < old > , < new > )
< str > .isnumeric()
< str > .split()
@ -77,23 +77,23 @@ str.replace(<text>, <old>, <new>)
```
### Print
```
```python
print(< el1 > , < el2 > , end='', sep='', file=< file > )
```
### Regex
```
```python
import re
re.sub(< regex > , < new > , < text > )
re.search(< regex > , < text > )
```
### Format
```
```python
'{}'.format(< el > )
```
```
```python
{:< min width > } -> '< el > '
{:>< min width > } -> ' < el > '
{:^< min width > } -> ' < el > '
@ -104,7 +104,7 @@ re.search(<regex>, <text>)
```
### Text Wrap
```
```python
import textwrap
textwrap.wrap(< text > , < width > )
```
@ -112,7 +112,7 @@ textwrap.wrap(<text>, <width>)
Random
------
```
```python
import random
random.random()
random.randint(< from inclusive > , < to inclusive > )
@ -121,13 +121,13 @@ random.shuffle(<list>)
Infinity
--------
```
```python
float("inf")
```
Datetime
--------
```
```python
import datetime
now = datetime.datetime.now()
now.strftime('%Y%m%d')
@ -138,13 +138,13 @@ now.strftime('%Y%m%d%H%M%S')
Inline
------
### Lambda
```
```python
lambda < arg1 > , < arg2 > : < return value >
lambda: < return value >
```
### Comprehension
```
```python
[i+1 for i in range(10)]
[i for i in range(10) if i>5]
[i+j for i in range(10) for j in range(10)]
@ -153,7 +153,7 @@ lambda: <return value>
```
### Map, Filter, Reduce
```
```python
A. map(lambda x: x+1, range(10))
B. filter(lambda x: x>5, range(10))
functools.reduce(combining_function, list_of_inputs)
@ -162,7 +162,7 @@ functools.reduce(combining_function, list_of_inputs)
Closure
-------
```
```python
def mult_clos(x):
def wrapped(y):
return x * y
@ -174,7 +174,7 @@ mul_by_3 = mult_clos(3)
Decorator
---------
```
```python
@closure_name
def function_that_gets_passed_to_closure():
...
@ -183,7 +183,7 @@ def function_that_gets_passed_to_closure():
Generator
---------
```
```python
def step(start, step):
while True:
yield start
@ -197,7 +197,7 @@ next(stepper)
Class
-----
### Class
```
```python
class < name > :
def __init__ (self, < arg > ):
self.a = < arg >
@ -208,14 +208,14 @@ class <name>:
```
### Enum
```
```python
import enum
class < name > (enum.Enum):
< value > = < index >
```
### Copy
```
```python
import copy
copy.copy(< object > )
copy.deepcopy(< object > )
@ -226,49 +226,49 @@ System
------
### Arguments
```
```python
import sys
sys.argv
```
### Read File
```
```python
with open(< filename > , encoding='utf-8') as file:
return file.readlines()
```
### Write to File
```
```python
with open(< filename > , 'w', enconding='utf-8') as file:
file.write(< text > )
```
### Execute Command
```
```python
import os
os.popen(< command > ).read()
```
### Input
```
```python
filename = input('Enter a file name: ')
```
JSON
----
```
```python
import json
```
### Read File
```
```python
with open(< filename > , encoding='utf-8') as file:
return json.load(file)
```
### Write to File
```
```python
with open(< filename > , 'w', enconding='utf-8') as file:
file.write(json.dumps(< object > ))
```
@ -277,13 +277,13 @@ with open(<filename>, 'w', enconding='utf-8') as file:
SQLite
------
```
```python
import sqlite3
db = sqlite3.connect(< filename > )
```
### Read
```
```python
cursor = db.execute(< query > )
if cursor:
cursor.< fetchone / fetchall > ()
@ -291,7 +291,7 @@ db.close()
```
### Write
```
```python
db.execute(< query > )
db.commit()
```
@ -299,19 +299,19 @@ db.commit()
Threading
---------
```
```python
import threading
```
### Thread
```
```python
thread = threading.Thread(target=< function > , args=(< first arg > , ))
thread.start()
thread.join()
```
### Lock
```
```python
lock = threading.Rlock()
lock.acquire()
lock.release()
@ -323,62 +323,62 @@ Itertools
Every function returns an generator and can accept any collection.
All examples should be passed to list() to get the output.
```
```python
from itertools import *
```
### Chain
```
```python
>>> chain([1,2], range(3,5))
[1, 2, 3, 4]
```
### Combinations
```
```python
>>> combinations("abc", 2)
[('a', 'b'), ('a', 'c'), ('b', 'c')]
```
### Permutations
```
```python
>>> permutations("abc", 2)
[('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]
```
### Compress
```
```python
>>> compress("abc", [True, 0, 23])
['a', 'c']
```
### Count
```
```python
>>> a = count(5, 2)
>>> next(a), next(a)
(5, 7)
```
### Cycle
```
```python
>>> a = cycle("abc")
>>> [next(a) for _ in range(10)]
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a']
```
### Groupby
```
```python
>>> {k: list(v) for k, v in groupby("aabbbc")}
{'a': ['a', 'a'], 'b': ['b', 'b', 'b'], 'c': ['c']}
```
```
```python
>>> a = [{"id": 1, "name": "bob"}, {"id": 2, "name": "bob"}, {"id": 3, "name": "peter"}]
>>> {k: list(v) for k, v in groupby(a, key=lambda x: x["name"])}
{'bob': [{'id': 1, 'name': 'bob'}, {'id': 2, 'name': 'bob'}], 'peter': [{'id': 3, 'name': 'peter'}]}
```
### Product
```
```python
>>> list(product('ab', [1,2]))
[('a', 1), ('a', 2), ('b', 1), ('b', 2)]
```
@ -391,7 +391,7 @@ Introspection and Metaprograming
--------------------------------
Inspecting code at runetime and code that generates code.
```
```python
>>> class B:
... def __init__ (self):
... self.a= 'sdfsd'
@ -400,19 +400,19 @@ Inspecting code at runetime and code that generates code.
```
### Getattr
```
```python
>>> getattr(b, 'a')
'sdfsd'
```
### Hasattr
```
```python
>>> hasattr(b, 'c')
False
```
### Setattr
```
```python
>>> setattr(b, 'c', 10)
```
@ -420,11 +420,11 @@ Type
----
Type is the root class. If only passed the object it returns it's type.
Otherwise it creates new class (and not the instance!).
```
```python
type(class_name, parents[tuple], attributes[dict])
```
```
```python
BB = type('B', (), {'a': 'sdfsd', 'b': 123324}
b = BB()
```
@ -432,13 +432,13 @@ b = BB()
MetaClass
---------
Classes that creates classes.
```
```python
def my_meta_class(name, parents, attrs):
... do stuff
return type(name, parents, attrs)
```
or
```
```python
class MyMetaClass(type):
def __new__ (klass, name, parents, attrs):
... do stuff
@ -456,7 +456,7 @@ Do Stuff
Metaclass Attr
--------------
When class is created it checks if it has metaclass defined. If not, it recursively checks if any of his parents has it defined, and eventually comes to type.
```
```python
class BlaBla:
__metaclass__ = Bla
```
Jure Šorn
7 years ago