Python

[Bryce1010]

Ref

• CS41 [课程主页]
• Test-Driven Development with Python [youtube]
  • 这是一本非常棒的书，作者教你如何用TDD的范式来使用Django开发网站。
• DataCamp数据科学课程资料 [ulr]
• 5 free books for learning python [url]

[Bryce1010]

Image

PIL [document]

>>> from PIL import Image
>>> im = Image.open("hopper.ppm")

>>> print(im.format, im.size, im.mode)
# PPM (512, 512) RGB

Reading and writing images

Image.open()
Image.save()

Cutting, pasting, and merging images

# Copying a subrectangle from an image
box = (100, 100, 400, 400)
region = im.crop(box)

# Processing a subrectangle, and pasting it back
region = region.transpose(Image.ROTATE_180)
im.paste(region, box)

# Splitting and merging bands  
r, g, b = im.split()
im = Image.merge("RGB", (b, g, r))

Geometrical transforms

out = im.resize((128, 128))
out = im.rotate(45) # degrees counter-clockwise

out = im.transpose(Image.FLIP_LEFT_RIGHT)
out = im.transpose(Image.FLIP_TOP_BOTTOM)
out = im.transpose(Image.ROTATE_90)
out = im.transpose(Image.ROTATE_180)
out = im.transpose(Image.ROTATE_270)

Color transforms

from PIL import Image
with Image.open("hopper.ppm") as im:
    im = im.convert("L")

Image sequences

from PIL import ImageSequence
for frame in ImageSequence.Iterator(im):
    # ...do something to frame...

imageio

[Bryce1010]

Python Digital Structure

python sets

https://realpython.com/python-sets/

## 从其他可迭代对象创建sets

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}  


>>> s = 'quux'

>>> list(s)
['q', 'u', 'u', 'x']
>>> set(s)
{'x', 'u', 'q'}

直接用{}创建sets

>>> x = {'foo', 'bar', 'baz', 'foo', 'qux'}
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = {'q', 'u', 'u', 'x'}
>>> x
{'x', 'q', 'u'}

• Set Size and Membership

>>> x = {'foo', 'bar', 'baz'}

>>> len(x)
3

>>> 'bar' in x
True
>>> 'qux' in x
False

```

- Operators vs. Methods
```python
# 取并集 
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 | x2
{'baz', 'quux', 'qux', 'bar', 'foo'}

# 等价于
>>> x1.union(x2)
{'baz', 'quux', 'qux', 'bar', 'foo'}

# 取交集  
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.intersection(x2)
{'baz'}

>>> x1 & x2
{'baz'}


# x1-x2  
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.difference(x2)
{'foo', 'bar'}

>>> x1 - x2
{'foo', 'bar'}

# 取异或  
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.symmetric_difference(x2)
{'foo', 'qux', 'quux', 'bar'}

>>> x1 ^ x2
{'foo', 'qux', 'quux', 'bar'}


# 判断是否有相同元素
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.isdisjoint(x2)
False

>>> x2 - {'baz'}
{'quux', 'qux'}
>>> x1.isdisjoint(x2 - {'baz'})
True

# 判断是否是子集
>>> x1 = {'foo', 'bar', 'baz'}
>>> x1.issubset({'foo', 'bar', 'baz', 'qux', 'quux'})
True

>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 <= x2
False


# 更新sets
>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 |= x2
>>> x1
{'qux', 'foo', 'bar', 'baz'}

>>> x1.update(['corge', 'garply'])
>>> x1
{'qux', 'corge', 'garply', 'foo', 'bar', 'baz'}

# 删除sets元素
>>> x = {'foo', 'bar', 'baz'}

>>> x.remove('baz')
>>> x
{'bar', 'foo'}

>>> x.remove('qux')
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    x.remove('qux')
KeyError: 'qux'

# 清除sets
>>> x = {'foo', 'bar', 'baz'}
>>> x
{'foo', 'bar', 'baz'}
>>> 
>>> x.clear()
>>> x
set()

```

[Bryce1010]

Using the Python zip() Function for Parallel Iteration

https://realpython.com/python-zip-function/

Passing n Arguments

>>> numbers = [1, 2, 3]
>>> letters = ['a', 'b', 'c']
>>> zipped = zip(numbers, letters)
>>> zipped  # Holds an iterator object
<zip object at 0x7fa4831153c8>
>>> type(zipped)
<class 'zip'>
>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

# zip 可以转化为list类型
>>> s1 = {2, 3, 1}
>>> s2 = {'b', 'a', 'c'}
>>> list(zip(s1, s2))
[(1, 'a'), (2, 'c'), (3, 'b')]

# zip也可以传递多个参数
>>> integers = [1, 2, 3]
>>> letters = ['a', 'b', 'c']
>>> floats = [4.0, 5.0, 6.0]
>>> zipped = zip(integers, letters, floats)  # Three input iterables
>>> list(zipped)
[(1, 'a', 4.0), (2, 'b', 5.0), (3, 'c', 6.0)]

# zip的参数长度也可以不同
>>> list(zip(range(5), range(100)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

# 如果要保持长度的话
>>> from itertools import zip_longest
>>> numbers = [1, 2, 3]
>>> letters = ['a', 'b', 'c']
>>> longest = range(5)
>>> zipped = zip_longest(numbers, letters, longest, fillvalue='?')
>>> list(zipped)
[(1, 'a', 0), (2, 'b', 1), (3, 'c', 2), ('?', '?', 3), ('?', '?', 4)]

Looping Over Multiple Iterables

# 利用lzip遍历list
>>> letters = ['a', 'b', 'c']
>>> numbers = [0, 1, 2]
>>> for l, n in zip(letters, numbers):
...     print(f'Letter: {l}')
...     print(f'Number: {n}')
...
Letter: a
Number: 0
Letter: b
Number: 1
Letter: c
Number: 2

# 也可以并行遍历字典 dict
>>> dict_one = {'name': 'John', 'last_name': 'Doe', 'job': 'Python Consultant'}
>>> dict_two = {'name': 'Jane', 'last_name': 'Doe', 'job': 'Community Manager'}
>>> for (k1, v1), (k2, v2) in zip(dict_one.items(), dict_two.items()):
...     print(k1, '->', v1)
...     print(k2, '->', v2)
...
name -> John
name -> Jane
last_name -> Doe
last_name -> Doe
job -> Python Consultant
job -> Community Manager


# unzip
>>> pairs = [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
>>> numbers, letters = zip(*pairs)
>>> numbers
(1, 2, 3, 4)
>>> letters
('a', 'b', 'c', 'd')


# 排序  
>>> letters = ['b', 'a', 'd', 'c']
>>> numbers = [2, 4, 3, 1]
>>> data1 = list(zip(letters, numbers))
>>> data1
[('b', 2), ('a', 4), ('d', 3), ('c', 1)]
>>> data1.sort()  # Sort by letters
>>> data1
[('a', 4), ('b', 2), ('c', 1), ('d', 3)]
>>> data2 = list(zip(numbers, letters))
>>> data2
[(2, 'b'), (4, 'a'), (3, 'd'), (1, 'c')]
>>> data2.sort()  # Sort by numbers
>>> data2
[(1, 'c'), (2, 'b'), (3, 'd'), (4, 'a')]

# 按照不同的关键字排序
>>> letters = ['b', 'a', 'd', 'c']
>>> numbers = [2, 4, 3, 1]
>>> data = sorted(zip(letters, numbers))  # Sort by letters
>>> data
[('a', 4), ('b', 2), ('c', 1), ('d', 3)]


# 成对计算 
>>> total_sales = [52000.00, 51000.00, 48000.00]
>>> prod_cost = [46800.00, 45900.00, 43200.00]
>>> for sales, costs in zip(total_sales, prod_cost):
...     profit = sales - costs
...     print(f'Total profit: {profit}')
...
Total profit: 5200.0
Total profit: 5100.0
Total profit: 4800.0


# 构建字典  
>>> fields = ['name', 'last_name', 'age', 'job']
>>> values = ['John', 'Doe', '45', 'Python Developer']
>>> a_dict = dict(zip(fields, values))
>>> a_dict
{'name': 'John', 'last_name': 'Doe', 'age': '45', 'job': 'Python Developer'}
>>> new_job = ['Python Consultant']
>>> field = ['job']
>>> a_dict.update(zip(field, new_job))
>>> a_dict
{'name': 'John', 'last_name': 'Doe', 'age': '45', 'job': 'Python Consultant'}

[Bryce1010]

阅读Python源码，剖析深度学习框架细节；
记录python代码模板；

New feature n Python3.8，:= assign from an expression

# the old way
order=input()
while order!="Nothing else":
    print("you are ordering:"+order)
    order=input()
    
# using assignment expression
while(order:=input()!="Nothing else"):
    print("you are ordering:"+order)

is vs ==

== for quality testing

is operator checks identiry instead of quality

x="cs41 rock"
y="cs41 "
x==y # True
x is y # False
id(x)
id(y)
[1,2,3] is [1,2,3] # False

string

string.find()

string.replace()

string.startswith()

string.endswith()

string.isalpha()

string.lower()

string.title()

string.upper()

string.strip()

string.strip(‘.nrH’)  

string.split()

string.join()     ‘.’.join([‘Zheng’, ’Antonio’, ‘Sam’])

File I/O

Python文件数据读写

获取目录列表

os.listdir() os.scandir() pathlib.Path

os.scandir [document]

pathlib.Path

列出子目录

os.lisdir() os.path()

DataStructures

这一小节总结python的数据结构：list, tuple, dict, set, 一些进阶循环的套路以及comprehension

list

list.append() # 添加元素

len(list) # list长度

list.count(value) # 计算某个值出现次数

list.extend(iterable) # 从可迭代对象扩展数组

list.insert(index,elem) # 在下标index位置插入元素

list.sort(key=None,reverse=False) # 对list排序

list.reverse() # 翻转数组

list.pop(i) # 删除下标i的元素

list.remove(value) # 删除第一个value

tuples

len(tuple) # tuple的长度

dict

len(dict) # 返回dict的key的数量

dict.get(“CS”, []) # return value if the key not in dict

dict.pop(“three”, None) # return value if key not in dict

dict.keys()

dict.values()

dict.items()

for key,value in dict.item():
	print(key,value)
    
keys_list=list(dict.keys())
for key in dict:
	print(key)
# 等价于
for key in dict.keys()

key in dict # 等价于 key in d.keys()

value in dict.values()

dict.copy() # shadow copy

dict.clear()

set

Unordered, finite collection of distinct, hashable elements.

student={‘san’, ‘si’, ‘wu’}

a=set(‘mississippi’) # {‘i’, ‘m’, ‘p’, ‘s’}

a.add(‘unicorn’)

a.remove(‘m’)

a.discard(‘x’)

a.pop() # 随机选一个元素

a.clear()

常用的集合运算

a = set('abracadabra') # {'a', 'r', 'b', 'c', 'd'}
b = set('alacazam') # {'a', 'm', 'c', 'l', 'z'}

Set difference (letters in a but not in b)

a - b # => {'r', 'd', 'b'}

Set union (letters in a or b or both)

a | b # => {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

Set intersection (letters in both a and b)

a & b # => {'a', 'c'}

Symmetric difference (letters in a or b but not both)

a ^ b # => {'r', 'd', 'b', 'm', 'z', 'l'}  

a < b # strict subset
a <= b # subset or equal to
a > b # strict superset
a >= b # superset or equal to

进阶循环

zip

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']

for q, a in zip(questions, answers):
	print('What is your {0}? It is {1}.'.format(q, a))

# What is your name? It is lancelot.
# What is your quest? It is the holy grail.
# What is your favorite color? It is blue.

sorted

basket = ['apple', 'orange', 'apple', 'pear', 'orange’, 'banana']

for f in sorted(set(basket)):
     print(f)

# apple
# banana
# orange
# pear

comprehensions

[x ** 2 for x in range(10)]
[fn(x) for x in iterable]
[fn(x) for x in iterable if cond(x)]

# example
[word.lower() for word in sentence]
[ch for ch in word.lower() if ch not in 'aeiou']

[(x, x**2, x**3) for x in seq]
[(i,j) for i in range(5) for j in range(i)]

Function

Codin style

The first string literal inside a function body is a docstring.
First line: one-line summary of the function.
Subsequent lines: extended description of function.
Describe parameters (value / expected type) and return (value / type).

Naming
Use snake_case for variables/functions; CamelCase for classes;
CAPS_CASE for constants.

Functional Programming

lambda

>>> # Find the maximum in a list of pairs by value of the second element.
>>>
>>> pairs = [(3, 2), (-1, 5), (4, 4)]
>>> max(pairs, key=lambda tup: tup[1])
(-1, 5)


>>> # Sort a collection of pairs by the value of the second element.
>>>
>>> pairs = [(3, 2), (-1, 5), (4, 4)]
>>> sorted(pairs, key=lambda tup: tup[1])
[(3, 2), (4, 4), (-1, 5)]

>>> trip = lambda x: 3*x

map

>>> [f(x) for x in iterable]

map(f,iterable)
def length_of_all_elements(arr):
	return list(map(len, arr))

>>> length_of_all_elements(["Parth", "Unicorn", "Michael"])
[5, 7, 7]

filter

filter(condition, iterable)

def starts_with_M(arr):
	return list(filter(lambda word: word[0].lower() == "m", arr))

>>> starts_with_M(["Michael","Parth"])

["Michael"]

Here, "condition" is a function that takes in an element of the iterable and returns something
truthy or falsy.

iterators

首先提出一个问题，map和filter返回什么值？

>>> arr = ["Parth", "Michael"]

>>> map_to_investigate = map(lambda x: x + "likes unicorns", arr)
>>> map_to_investigate
<map object at 0x10c6a0550>
>>> filter_to_investigate = filter(lambda x: x == "Unicorn", arr)
>>> filter_to_investigate
<filter object at 0x10c6a0510>

map和filter对象都是迭代器，代表了有限个或无限个数据流；

使用next(iterator)函数访问迭代器的元素；

使用iter(data_structure)将数据结构构建为迭代器。

>>> names = ["Parth", "Michael", "Unicorn"]

>>> length_filter = filter(lambda word: len(word) >= 7, names)
>>> next(length_filter)
"Michael"
>>> next(length_filter)
"Unicorn"
>>> next(length_filter)
Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
StopIteration
>>>

对for循环使用迭代器：

# This code...
for data in data_source:
	do_something_to(data)
# ...is equivalent to...
data_iter = iter(data_source)
while True:
	try:
		data = next(data_iter)
	except StopIteration:
		break
	else:
		do_something_to(data)

有限的迭代器可以读入到数据结构中：

def starts_with_M(arr):
	return list(filter(lambda st: st[0].lower() == "m", arr))

Generator

返回一个迭代器，可以生成一串数据；

局部变量不会在暂停时回收，会在上一次暂停处继续学习。

# Let's write a generator to generate the Fibonacci sequence!
def fib():
	a, b = 0, 1
	while True:
		a, b = b, a+b
		yield a

>>> g = fib() # Namespace created, fib() pushed to stack.
>>> type(g)
<class 'generator'>
>>> next(g)
1
>>> next(g)
1 # next(g) : 2, 3, 5, 8, 13, 21, 34...
>>> max(g) # What happens?

# Generating the Fibonacci sequence only on demand
def fibs_under(n):
	for num in fib(): # The generator we just made! Loops over 1, 1, 2...
		if num > n:
			break
		print(num)

为什么要使用Generator？

可以用命令计算数据，避免昂贵的函数调用，减少内存消耗；

允许我们定义无限的数据流；

Decorator

回忆一下前面学习的知识：

我们可以从函数中返回一个函数：

def make_divisibility_test(n):
	def is_divisible_by(m):
		return m % n == 0
	return is_divisible_by

>>> div_test = make_divisibility_test(5) # "test" is a function!
>>> div_test(256)
False
>>> div_test(10)
True
>>>

decorator输入一个函数，修改这个函数，返回修改后的函数。

# Our first decorator
def debug(function):
	def modified_function(*args, **kwargs):
		print("Arguments:", args, kwargs)
		return function(*args, **kwargs)
	return modified_function

@debug
def foo(a, b, c=1):
	return (a + b) * c

Python 面向对象编程

Magic methods

Magic methods可以让自定义的类和python内建函数无缝连接。

x = MagicClass()
y = MagicClass()
str(x) # => x.__str__()
x == y # => x.__eq__(y)
x < y # => x.__lt__(y)
x + y # => x.__add__(y)
iter(x) # => x.__iter__()
next(x) # => x.__next__()
len(x) # => x.__len__()
el in x # => x.__contains__(el)

举个例子：

class Point:
	def __init__(self, x=0, y=0):
		self.x = x
		self.y = y
def rotate_90_counterclockwise(self):
	self.x, self.y = -self.y, self.x
def __add__(self, other):
	return Point(self.x + other.x, self.y + other.y)
def __str__(self):
	return "Point({0}, {1})".format(self.x, self.y)

Python Web

json

# Load JSON from a file
file_data = json.load(f)
# Load JSON from a string
s_data = json.loads('{"Michael": "Favourite Canadian"}')
# Convert Python data to JSON, store in a file
json.dump(obj, f)
# Convert Python data to JSON, return as string
json.dumps(obj)

numpy

ndarray

create an ndarray

# ndarrays do not accept generators! So be default, you can't do
# list comprehensions with them.
>>> np.array((x*x for x in range(5))
array(<generator object <genexpr> at 0x112b25900>, dtype=object)

# Instead, use np.fromiter to construct your array!
>>> np.fromiter((x*x for x in range(5))
array([0., 1., 4., 9., 16.])

Elementwise Matrix Operations

# Compute the elementwise sum array1 + array2
np.add(array1, array2)
# Compute the elementwise difference array1 ‚ÀÓ array2
np.subtract(array1, array2)
# Compute the elementwise product array1 * array 2
np.multiply(array1, array2)
# Compute the elementwise quotient array1 / array2
np.divide(array1, array2)

# Compute the inner product of two arrays
np.dot(array1, array2)
# Compute the outer product of two arrays
np.outer(array1, array2)
# Compute the elementwise product array1 * array 2
np.matmul(array1, array2)
# (Equivalent shortcut: array1 @ array2)

# numpy is full of functions to perform matrix operations.
# (If you don't know all these concepts, don't worry! But those
# familiar with linear algebra may be interested).
np.linalg.norm(A) # Compute the norm of matrix A
np.linalg.eig(A) # Tuple: (eigenvalues, eigenvectors) of A
np.linalg.det(A) # Determinant of matrix A
np.linalg.matrix_rank(A) # Rank of A
np.linalg.qr(A) # Tuple: (Q, R) factorization of A
np.linalg.svd(A) # Tuple: (U, S, V) SVD of A.
np.linalg.matrix_power(A, k) # Returns the matrix exponential A^k

Reshape

# Takes in A, an (m, n) matrix, returns A^T, an (n, m) matrix.
>>> np.transpose(A)
# Equivalent shortcut (yes, numpy will parse this correctly).
>>> A.T

# Reshapes a matrix A into an (m, n) matrix
np.reshape(A, (m, n))

statistical Methods

np.mean(A, axis=i) # Mean of elements of A along axis i
np.average(A, axis=i, weights=None) # Weighted average of A along axis i
# (weights argument is optional).
np.std(A, axis=i) # Std. dev. of A along axis i
np.median(A, axis=i) # Median of A along axis i
np.var(A, axis=i) # Variance of A along axis i

标准库和第三方工具

[Python Standard Library]

• Modules and Packages
• pdb – Python's Debugger!
• collections – Specialized Containers for Data!
• itertools – Better Iterators!
• functools – Functions on Callable Objects!
• re – Regular Expressions, Pattern Matching!
• pickle – Object Serialization!
• pathlib – Object-Oriented Filesystem!
• threading – Thread-Based Parallelism!

collections

collections.namedtuple

# Using namedtuple to make our example better!
Maze_Point = collections.namedtuple("Maze_Point", ["north", "east", "south", "west"])
p = Maze_Point(None, "y1WP2aidto.json",

"CikNQoaeFM.json"

, None)

p.east #=> "y1WP2aidto.json"
p.south #=> "CikNQoaeFM.json"
# Much better!

collections.defaultdict

# Here's a beautiful way!
input_data = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4),('red', 1)]
# Make the default value an empty list - that way we don't need to set
# a value for keys which aren't in the dictionary already.
d = collections.defaultdict(list)
for k, v in input_data:
d[k].append(v)

collections.Counter

# collections.Counter does this for us!
num_each_animal = dict(collections.Counter(s))
# collections.Counter returns a Counter object:
# collections.Counter(s) = Counter({'': 4, '': 3, '': 2, '': 1})

itertools

pickle

data = np.array([.........]) # Some object - this can be any Python object!

with open('data_file_name.pickle','wb') as f:
	pickle.dump(data, f)

with open('data_file_name.pickle','rb') as f:
	data = pickle.load(f)    

pathlib

from pathlib import Path
p = Path("path/to/file.txt") # This can be any filepath!
p.is_dir() #=> False
p.is_file() #=> True
p.parts #=> ('/', 'path', 'to', 'file.txt')
p.parent() #=> PosixPath('/path/to')
p.Parent / "other_dir" #=> PosixPath('/path/to/other_dir')

Machine Learning

• plt.show() 函数

  plt.plot(x,y)
  plt.plot(x,y, format_str)
  plt.plot(y)
  plt.plot(y, format_str)

字符	颜色
‘b’	蓝色，blue
‘g’	绿色，green
‘r’	红色，red
‘c’	青色，cyan
‘m’	品红，magenta
‘y’	黄色，yellow
‘k’	黑色，black
‘w’	白色，white

字符	类型	字符	类型
'-'	实线	'--'	虚线
'-.'	虚点线	':'	点线
'.'	点	','	像素点
'o'	圆点	'v'	下三角点
'^'	上三角点	'<'	左三角点
'>'	右三角点	'1'	下三叉点
'2'	上三叉点	'3'	左三叉点
'4'	右三叉点	's'	正方点
'p'	五角点	'*'	星形点
'h'	六边形点1	'H'	六边形点2
'+'	加号点	'x'	乘号点
'D'	实心菱形点	'd'	瘦菱形点
'_'	横线点

sklearn

• sklearn.exceptions: Exceptions and warnings

• sklearn.experimental: Experimental

• sklearn.feature_extraction: Feature Extraction

• sklearn.feature_selection: Feature Selection

• sklearn.gaussian_process: Gaussian Processes

• sklearn.impute: Impute

• sklearn.inspection: inspection

• sklearn.isotonic: Isotonic regression

• sklearn.kernel_approximation Kernel Approximation

• sklearn.kernel_ridge Kernel Ridge Regression

• sklearn.linear_model: Linear Models

• sklearn.manifold: Manifold Learning

sklearn.metrics: Metrics

accuracy_score(y_true, y_pred[, normalize, …])	Accuracy classification score.
classification_report(y_true, y_pred[, …])	Build a text report showing the main classification metrics
f1_score(y_true, y_pred[, labels, …])	Compute the F1 score, also known as balanced F-score or F-measure
fbeta_score(y_true, y_pred, beta[, labels, …])	Compute the F-beta score
hamming_loss(y_true, y_pred[, labels, …])	Compute the average Hamming loss.
jaccard_score(y_true, y_pred[, labels, …])	Jaccard similarity coefficient score
log_loss(y_true, y_pred[, eps, normalize, …])	Log loss, aka logistic loss or cross-entropy loss.
multilabel_confusion_matrix(y_true, y_pred)	Compute a confusion matrix for each class or sample
precision_recall_fscore_support(y_true, y_pred)	Compute precision, recall, F-measure and support for each class
precision_score(y_true, y_pred[, labels, …])	Compute the precision
recall_score(y_true, y_pred[, labels, …])	Compute the recall
roc_auc_score(y_true, y_score[, average, …])	Compute Area Under the Receiver Operating Characteristic Curve (ROC AUC) from prediction scores.
zero_one_loss(y_true, y_pred[, normalize, …])	Zero-one classification loss.

• sklearn.mixture: Gaussian Mixture Models

• sklearn.model_selection: Model Selection

• sklearn.multiclass: Multiclass and multilabel classification

• sklearn.multioutput: Multioutput regression and classification

• sklearn.naive_bayes: Naive Bayes

• sklearn.neighbors: Nearest Neighbors

• sklearn.neural_network: Neural network models

• sklearn.pipeline: Pipeline

• sklearn.preprocessing: Preprocessing and Normalization

• sklearn.random_projection: Random projection

• sklearn.semi_supervised Semi-Supervised Learning

• sklearn.svm: Support Vector Machines

• sklearn.tree: Decision Trees

• sklearn.utils: Utilities

OpenCV

[Bryce1010]

OpenSlide

• OpenSlide Python [url]
  The benefit of OpenSlide is that we can load arbitrary regions of the slide, without loading the whole image in memory.
  

[Bryce1010]

4 Super Useful Python Features [medium]

• List methods: append and extend

x = [1, 2, 3]
y = [4, 5]
x.append(y)
print(x)

x = [1, 2, 3]
y = [4, 5]
x.extend(y)
print(x)

• Yield vs Return

def generator_yield():
    yield "hel"
    yield "lo "
    yield "wor"
    yield "ld!"
def generator_return():
    return "hel"
    return "lo "
    return "wor"
    return "ld!"

• print(start, end)

generator = (x for x in [1, 2, 3])
for _ in generator:
    print(_, end=" ")

• map and lambda

results = [(0.1, 0.2), (0.3, 0.1), (0.2, 0.4)]
list(map(lambda x: x[0], results))