Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
My Python Cheatsheet
Python Cheatsheet
=================
################################ Input & Output ###############################
name = input('please enter your name: ')
print('hello,', name)
ageStr = input('please enter your age: ')
age = int(ageStr)
#################################### String ####################################
"I'm OK"
'I\'m \"OK\"!'
r'\\\t\\'
'''line1
line2
line3'''
################################ Python's Null ################################
None
################################### Division ###################################
10 / 3
10 // 3
10 % 3
############################## Unicode <--> char ##############################
ord('A')
chr(66)
'\u4e2d\u6587'
#################################### Bytes ####################################
b'ABC'
############################### Encode & Decode ###############################
'中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'ABC'.encode('ascii')
b'ABC'.decode('ascii')
################################ String format ################################
'Hi, %s, you have $%d.' % ('Michael', 1000000)
'%.2f' % 3.1415926
'Age: %s. Gender: %s' % (25, True) # bool->true
%d int
%f float
%s str
%x hex int
a = 'abc'
b = a.replace('a', 'A')
b # = 'Abc'
a # = 'abc'
##################################### List #####################################
classmates = ['Michael', 'Bob', 'Tracy']
len(classmates)
classmates[-1] = 'Sarah'
classmates.append('Adam')
classmates.insert(1, 'Jack')
classmates.pop()
L0 = []
L1 = ['Apple', 123, True]
L2 = ['python', 'java', ['asp', 'php'], 'scheme']
len(L2) # = 4;
################################ Slice of list ################################
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3] # = ['Michael', 'Sarah', 'Tracy']
L[:3] # same
L[:-2] # same
L = list(range(100))
L[:10:2] # = [0, 2, 4, 6, 8]
L[::5] # [0, 5, 10, 15, 20, 25, 30 ... 90, 95]
L[:] # [0, 1, 2, 3, ..., 99]
#################################### Tuple ####################################
classmates = ('Michael', 'Bob', 'Tracy')
classmates[-1]
t = ()
t = (1,) # attention comma!
t = (1, 2)
################################# Other slice #################################
(0, 1, 2, 3, 4, 5)[:3] # = (0, 1, 2)
'ABCDEFG'[:3]
################################ 'if' statement ################################
age = 20
if age >= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')
if x:
print('True')
# x -> True when x is:
# non-zero int, non-empty str, non-empty list/tuple
############################### 'for' statement ###############################
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
list(range(5)) # = [0, 1, 2, 3, 4]
sum = 0
for x in range(101):
sum = sum + x
############################## 'while' statement ##############################
sum = 0
x = 100
while x > 0:
sum = sum + x
x = x - 1
################################ Key-value dict ################################
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael'] # Get (= 95)
d['Adam'] = 67 # Insert
d['Adam'] = 90 # Replace
'Thomas' in d # False
d.get('Thomas', -1) # -1
d.pop('Bob') # Delete
##################################### Set #####################################
s = set([1, 2, 3])
set([1, 1, 2, 2, 3, 3]) # {1, 2, 3}
s.add(4) # no effect if duplicated
s.remove(4)
s1 & s2 # intersection
s1 | s2 # union
##################################### Math #####################################
abs(-100)
max(3, 2, -3, -5)
############################### Type convertion ###############################
int('123')
int(12.34)
float('12.34')
str(1.23)
str(100)
bool(1) # True
bool('') # False
############################### 'pass' statement ###############################
def nop():
pass
if age >= 18:
pass
############################ 'isinstance' statement ############################
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
############################# return multi values #############################
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
ret = move(...) # -> tuple
##################### Named arguments & default arguments #####################
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
enroll('Sarah', 'F')
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')
def add_end(L=[]): # L is created every time
L.append('END')
return L
add_end() # ['END']
add_end() # ['END', 'END']
add_end() # ['END', 'END', 'END']
# corrected:
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
################################### '*args' ###################################
def calc(*numbers): # arg list -> tuple
sum = 0
for n in numbers:
sum = sum + n * n
return sum
calc(1, 2)
calc(1, 2, 3)
calc()
calc(*nums) # list/tuple -> arg list
################################## '**kwargs' ##################################
def person(name, age, **kw): # arg list -> dict
print('name:', name, 'age:', age, 'other:', kw)
person('Michael', 30) # kw = {}
person('Bob', 35, city='Beijing')
# kw = {'city': 'Beijing'}
person('Adam', 45, gender='M', job='Engineer')
# kw = {'gender': 'M', 'job': 'Engineer'}
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra) # dict -> arg list
################################# Named params #################################
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
person('Jack', 24, city='Beijing', job='Engineer')
person('Jack', 24, 'Beijing', 'Engineer') # error
############################### Iterator on dict ###############################
d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
print(key) # a b c
for value in d.values():
print(value) # 1 2 3
for k, v in d.items():
print(k, v)
################################### Iterable ###################################
from collections import Iterable
isinstance('abc', Iterable) # True
isinstance(123, Iterable) # False
################################ List Generator ################################
[x * x for x in range(1, 11)]
[x * x for x in range(1, 11) if x % 2 == 0]
[m + n for m in 'ABC' for n in 'XYZ']
[k + '=' + v for k, v in d.items()]
L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]
################################## Generator ##################################
(x * x for x in range(10))
next(g) # 0
next(g) # 1
next(g) # 4 ...
G = (x * x for x in range(10))
for n in G:
print(n)
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
object = fib(10) # type = genetator object
def triangles():
result = [1]
while True:
yield result
a, b = [0] + result, result + [0]
result = [a[i] + b[i] for i in range(len(a))]
######################### Iterable / Iterator / iter() #########################
isinstance('abc', Iterable) # True
isinstance('abc', Iterator) # False
isinstance(iter('abc'), Iterator) # True
############################ Higher-order functions ############################
def add(x, y, f):
return f(x) + f(y)
add(-5, 6, abs) # = abs(-5) + abs(6) = 11
##################################### map #####################################
it = map(abs, [-1, -2, -3]) # iterator
list(it) # [1, 2, 3]
#################################### reduce ####################################
# reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def add(x, y):
return x + y
reduce(add, [1, 3, 5, 7, 9]) # 25
from functools import reduce
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
#################################### filter ####################################
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # = [1, 5, 9, 15]
# or: for x in filter(..) ....
################################### Sorting ###################################
sorted(['bob', 'about', 'Zoo', 'Credit'])
# ['Credit', 'Zoo', 'about', 'bob']
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
# ['about', 'bob', 'Credit', 'Zoo']
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
# ['Zoo', 'Credit', 'bob', 'about']
############################## Return a function ##############################
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
f = lazy_sum(1, 3, 5, 7, 9)
f # function
f() # 25
################################### Closure ###################################
def count():
def f(j): # Bind i->j
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i))
return fs
f1, f2, f3 = count()
################################## Decorator ##################################
import functools
def log(text):
def decorator(func):
@functools.wraps(func) # 把func的name等属性复制给wrapper
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator
@log("call")
def now():
print('2015-3-25')
now()
# call now():
# 2015-3-25
############################## A Standard Module ##############################
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
' a test module '
__author__ = 'Michael Liao'
import sys
def test():
args = sys.argv
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('Too many arguments!')
if __name__=='__main__':
test()
#################################### Class ####################################
class Student:
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print('%s: %s' % (self.__name, self.__score))
################################### Inherit ###################################
class Animal:
def run(self):
print('Animal is running...')
class Dog(Animal):
pass
class Tortoise(Animal):
def run(self):
print('Tortoise is running slowly...')
class Runnable:
def run(self):
print('Running...')
class Husky(Mammal, Runnable): # multi
pass
########################### Some built-in functions ###########################
isinstance(h, Husky)
isinstance(h, (int, float))
dir(object)
getattr(obj, 'attr')
setattr(obj, 'attr', 123)
hasattr(obj, 'attr')
class Student:
common_attr = 'hello'
def common_func():
pass
#################################### Slots ####################################
class Student(object):
__slots__ = ('name', 'age')
################################### Property ###################################
class Student:
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
s = Student()
s.score = 60 # OK, -> s.set_score(60)
s.score # OK -> s.get_score() -> 60
######################### Built-in functions of object #########################
__str__(self)
__repr__(self) # __repr__ = __str__
__iter__(self) # return an iterator object
__getitem__(self, n_or_slice) # [n] [n:m]
__getattr__(self, attr_name)
__call__(self)
################################## Enumerate ##################################
enumerate(['A', 'B', 'C']) # {0:'A', 1:'B', 2:'C'}
for i, value in enumerate(['A', 'B', 'C']):
print(i, value)
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
Month.Jan # == 1. Enum begins from 1
Month['Jan']
Month(1)
for name, member in Month.__members__.items():
print(name, '=>', member, ',', member.value)
############################ Another usage of enum ############################
from enum import Enum, unique
@unique # make sure no duplicated values
class Weekday(Enum):
Sun = 0 # set Sun = 0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
######################## 'try' statement and exception ########################
try:
print('try...')
r = 10 / 0
print('result:', r)
except ZeroDivisionError as e:
print('except:', e)
else:
pass
finally:
print('finally...')
print('END')
class FooError(ValueError):
pass
raise FooError('invalid value: %s' % s)
################################ logging module ################################
import logging
logging.exception(e)
logging.info('info') # debug, info, warning, error
logging.basicConfig(level=logging.INFO)
############################## 'assert' statement ##############################
assert n != 0, 'n is zero!'
# python -O to shut down asserts
################################## Unit test ##################################
import unittest
from mydict import Dict
class TestDict(unittest.TestCase):
def test_init(self):
d = Dict(a=1, b='test')
self.assertEqual(d.a, 1)
self.assertEqual(d.b, 'test')
self.assertTrue(isinstance(d, dict))
def test_keyerror(self):
d = Dict()
with self.assertRaises(KeyError):
value = d['empty']
def other_func(self): # not run
pass
def setUp(self):
print('setUp...')
def tearDown(self):
print('tearDown...')
if __name__ == '__main__':
unittest.main()
# or python3 -m unittest mydict_test
################################### Doctest ###################################
# `...` for some output
class Dict(dict):
'''
Simple dict but also support access as x.y style.
>>> d1 = Dict()
>>> d1['x'] = 100
>>> d1.x
100
>>> d1.y = 200
>>> d1['y']
200
>>> d2 = Dict(a=1, b=2, c='3')
>>> d2.c
'3'
>>> d2['empty']
Traceback (most recent call last):
...
KeyError: 'empty'
>>> d2.empty
Traceback (most recent call last):
...
AttributeError: 'Dict' object has no attribute 'empty'
'''
############################### File Operations ###############################
f = open('/Users/michael/notfound.txt', 'r')
f.read() # read all -> str
f.readline()
f.read(size_in_bytes)
f.readlines() # -> list
f.close()
with open('/path/to/file', 'r') as f:
for line in f.readlines():
print(line.strip()) # delelte '\n'
# close when leaving 'with' block
f = open('/Users/michael/test.jpg', 'rb')
f.read() # -> bytes
f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')
f.read() # -> str
f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')
f = open('/Users/michael/test.txt', 'w')
f.write('Hello, world!')
f.close()
with open('/Users/michael/test.txt', 'w') as f:
f.write('Hello, world!')
################################ String Buffer ################################
from io import StringIO
f.write('hello')
f.write('world!')
print(f.getvalue())
from io import StringIO
f = StringIO('Hello!\nHi!\nGoodbye!')
s = f.readline()
################################# Bytes Buffer #################################
from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())
################################# 'os' module #################################
import os
os.name # 'nt' for windows, 'posix' for linux/unix
os.environ
os.environ.get('PATH')
os.path.abspath('.')
os.path.join('/Users/michael', 'testdir')
os.mkdir('/Users/michael/testdir')
os.rmdir('/Users/michael/testdir')
os.path.split('/Users/michael/testdir/file.txt')
# ('/Users/michael/testdir', 'file.txt')
os.path.splitext('/path/to/file.txt')
# ('/path/to/file', '.txt')
os.rename('test.txt', 'test.py')
os.remove('test.py')
os.listdir('.')
[x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']
############################### 'pickle' module ###############################
import pickle
d = dict(name='Bob', age=20, score=88)
pickle.dumps(d) # -> bytes
with open('dump.txt', 'wb') as f:
pickle.dump(d, f)
with open('dump.txt', 'rb') as f:
d = pickle.load(f)
################################ 'json' module ################################
import json
d = dict(name='Bob', age=20, score=88)
json.dumps(d) # -> str
json_str = '{"age": 20, "score": 88, "name": "Bob"}'
json.loads(json_str) # -> dict
json.load(file)
import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
print(json.dumps(s, default=student2dict))
print(json.dumps(s, default=lambda obj: obj.__dict__))
def dict2student(d):
return Student(d['name'], d['age'], d['score'])
json_str = '{"age": 20, "score": 88, "name": "Bob"}'
json.loads(json_str, object_hook=dict2student))
############################## Regular expression ##############################
import re
re.match(r'^\d{3}\-\d{3,8}$', '010-12345') # Match object or None
re.split(r'\s+', 'a b c') # ['a', 'b', 'c']
m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
m.group(0) # '010-12345'
m.group(1) # '010'
m.group(2) # '12345'
m.groups() # ('010', '12345')
re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
re_telephone.match('010-12345')
################################# Data & Time #################################
from datetime import datetime
now = datetime.now()
print(now) # 2015-05-18 16:28:07.198690
dt = datetime(2015, 4, 19, 12, 20)
print(dt) # 2015-04-19 12:20:00
dt.timestamp() # 1429417200.0
dt = datetime.fromtimestamp(1429417200.0)
print(dt) # 2015-04-19 12:20:00
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
cday_str = cday.strftime('%a, %b %d %H:%M')
from datetime import datetime, timedelta
now = datetime.now()
now + timedelta(days=2, hours=12)
from datetime import datetime, timedelta, timezone
datetime.utcnow()
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
################################# Named tuple #################################
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
p.x # = 1
p.y # = 2
#################################### deque ####################################
from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
q.pop()
q.popleft()
################################# defaultdict #################################
from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
dd['key1'] # = 'abc'
dd['key2'] # = 'N/A'
################################# OrderedDict #################################
from collections import OrderedDict
od = OrderedDict()
od['z'] = 1
od['y'] = 2
od['x'] = 3
list(od.keys()) # ['z', 'y', 'x']
################################### Counter ###################################
from collections import Counter
c = Counter()
for ch in 'programming':
c[ch] = c[ch] + 1
#################################### base64 ####################################
import base64
base64.b64encode(b'binary\x00string')
# b'YmluYXJ5AHN0cmluZw=='
base64.b64decode(b'YmluYXJ5AHN0cmluZw==')
# b'binary\x00string'
base64.urlsafe_b64encode(b'i\xb7\x1d\xfb\xef\xff')
base64.urlsafe_b64decode('abcd--__')
################################# binary pack #################################
import struct
struct.pack('>I', 10240099) # '>' for big-endian, 'I' for 4-byte int
struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80')
# (4042322160, 32896)
struct.unpack('<ccIIIIIIHH', bmp_header)
##################################### Hash #####################################
import hashlib
md5 = hashlib.md5() # or hashlib.sha1()
md5.update('how to use md5 in '.encode('utf-8'))
md5.update('python hashlib?'.encode('utf-8'))
print(md5.hexdigest())
################################## itertools ##################################
import itertools
itertools.count(1) # 1 2 3 4 5 ...
itertools.cycle('ABC') # A B C A B ...
itertools.repeat('A') # A A A A A...
itertools.repeat('A', 3) # A A A [end]
natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x <= 10, natuals)
list(ns) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
itertools.chain('ABC', 'XYZ')
itertools.groupby('AAABBBCCAAA') # (key, group)
itertools.groupby('AaaBBbcCAAa', lambda c: c.upper())
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
################################ Web operation ################################
from urllib import request
req = request.Request('http://www.douban.com/')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
with request.urlopen(req) as f:
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', f.read().decode('utf-8'))
from urllib import request, parse
print('Login to weibo.cn...')
email = input('Email: ')
passwd = input('Password: ')
login_data = parse.urlencode([
('username', email),
('password', passwd),
('entry', 'mweibo'),
('client_id', ''),
('savestate', '1'),
('ec', ''),
('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
])
req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')
with request.urlopen(req, data=login_data.encode('utf-8')) as f:
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', f.read().decode('utf-8'))
########################## From Iterator to Coroutine ##########################
def consumer():
r = ''
while True:
n = yield r
if not n:
return
print('[CONSUMER] Consuming %s...' % n)
r = '200 OK'
def produce(c):
c.send(None)
n = 0
while n < 5:
n = n + 1
print('[PRODUCER] Producing %s...' % n)
r = c.send(n)
print('[PRODUCER] Consumer return: %s' % r)
c.close()
c = consumer()
produce(c)
################################## Coroutine ##################################
import asyncio
@asyncio.coroutine
def hello():
print("Hello world!")
# call asyncio.sleep(1) asynchronously
r = yield from asyncio.sleep(1)
print("Hello again!")
# Get EventLoop
loop = asyncio.get_event_loop()
# Run coroutine
loop.run_until_complete(hello())
loop.close()
# in python 3.5
async def hello():
print("Hello world!")
# call asyncio.sleep(1) asynchronously
r = await asyncio.sleep(1)
print("Hello again!")
@IdanBanani

This comment has been minimized.

Copy link

@IdanBanani IdanBanani commented Apr 30, 2020

very nice! Thanks. missing some functools methods but great.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.