1. Class
1.1 Class调用
常用的很多python功能都是class的method调用，比如下例的list，可以用两种写法来调用append method。
第一种L.append(5)，L创建了list的一个instance，继承了list class的所有method，所以在L中直接调用它的append method。
第二种list.append(L, 6)，虽然实现了一样的功能，但却使用了不同的方式。这种方法直接调用了list class的append method，传入两个参数，一个是list L，另一个是要添加的元素6。
也就是说，虽然两种方法输出一样，但是前者是instance object的调用，它继承了class的method，而后者是对list class的直接调用。
L = list([1, 2, 3])
L.append(5)
#list是class的name，[1,2,3]是argument，L是一个object，append是一个method，“.”代表在list中的method
list.append(L, 6)
L
1.2 print()调用
print()函数会调用class中str的method，如果没有，再调用repr的method。而直接使用instance的时候优先调用repr的method，所以以下程序输出不同：
x = str('abc')
x
>>> 'abc'
print(x)
>>> abc
#x的输出是'abc'，print(x)的输出是abc，因为x命令调用的是__repr__的method，print(x)调用的是__str__的method
1.3 class简述
class中有三种常见的method写法，其一是method名字前后有两个下划线，通常表示python自带需要规定的method；其二是method名字前面有一个method，通常表示是具体实现某个功能的后台method，不让用户直接调用；其三是没有任何下划线的method名字，这样的method通常表示是用户直接调用的方法，例如list中的append, pop等。
class中有几个常用重要的method：
（1）init用来定义class的attribute，attribute前面加前缀self；
（2）repr用来定义class调用自身时的输出；
（3）str用来定义class被print()调用时的输出
另外，在class的instance使用时，可以创建class中不存在的attribute，例如下面的一元二次方程的class中并没有name，但是可以在class外建立一个attribute：
SEO1.name = 'A great equation'
dir(SEO1)
>>>
...
'name'
...
1.4 一元二次方程class建立
from math import sqrt
class SecondOrderEquation:
def __init__(self, *, a = 1, b = 0, c = 0):
self.a = a
self.b = b
self.c = c
self.root_1, self.root_2 = self._compute_roots()
#变量有前缀self的时候代表是当前class的一个attribute，没有这个前缀则是一个local variable
def __repr__(self):
return f'SecondOrderEquation({self.a}, {self.b}, {self.c})'
def __str__(self):
#__str__是print()函数会查询的method
output_string = ''
if self.a == 1:
output_string = 'x^2'
elif self.a == -1:
output_string = '-x^2'
else:
output_string = f'{self.a}x^2'
if self.b == 1:
output_string += ' + x'
elif self.b == -1:
output_string += ' - x'
elif self.b > 0:
output_string += f' + {self.b}x'
elif self.b < 0:
output_string += f' - {-self.b}x'
if self.c > 0:
output_string += f' + {self.c}'
elif self.c < 0:
output_string += f' - {-self.c}'
return output_string
def _compute_roots(self):
delta = self.b ** 2 - 4 * self.a * self.c
if delta < 0:
root_1, root_2 = None, None
elif delta == 0:
root_1 = -self.b / (2 * self.a)
root_2 = root_1
else:
root_1 = (-self.b - sqrt(delta)) / (2 * self.a)
root_2 = (-self.b + sqrt(delta)) / (2 * self.a)
return root_1, root_2
def get_roots(self):
return self.root_1, self.root_2
SEO1 = SecondOrderEquation(a = 1, b = -2, c = 1)
print(SEO1)
SEO2 = SecondOrderEquation(a = -7, c = -4)
print(SEO2)
SEO3 = SecondOrderEquation()
print(SEO3)
SEO1, SEO2, SEO3
print(SecondOrderEquation.get_roots(SEO1))
print(SEO1.get_roots())
SEO1.a, SEO1.b, SEO1.c, SEO1.root_1, SEO1.root_2
1.5 attribute调用
如果attribute的形式是_name，则可以直接调用，例如：
SEO1._delta
如果attribute的形式是__name，则要用以下方式调用：
SEO1._SecondOrderEquation__delta
#双下划线开头的attribute使得attribute更难调用，程序更加安全
2. Exception自定义
在定义class时，经常要处理一些异常情况，往往与系统自带的常见exception不符合，比如ValueError。这个时候可以自定义Exception，并输出特定的提示文字。如下：
from fractions import Fraction
class FiniteProbabilityDistributionError(Exception):
#变量名应该是Exception
def __init__(self, message):
self.message = message
class FiniteProbabilityDistribution:
def __init__(self, mass_function):
if isinstance(mass_function, set):
self.mass_function = {outcome: Fraction(1, len(mass_function))
for outcome in mass_function}
elif not all(isinstance(mass_function[outcome], Fraction)
for outcome in mass_function):
raise FiniteProbabilityDistributionError('All values should be of type Fraction.')
也可以用一条创建的Exception来实现多种exception的提示：
from fractions import Fraction
class FiniteProbabilityDistributionError(Exception):
def __init__(self, message):
self.message = message
class FiniteProbabilityDistribution:
def __init__(self, mass_function):
if isinstance(mass_function, set):
self.mass_function = {outcome: Fraction(1, len(mass_function))
for outcome in mass_function}
return
if not all(isinstance(mass_function[outcome], Fraction)
for outcome in mass_function):
raise FiniteProbabilityDistributionError('All values should be of type Fraction.')
if sum(mass_function[outcome] for outcome in mass_function) != 1:
raise FiniteProbabilityDistributionError('All probabilites should add up to 1.')
3. 函数传参的pack与unpack
python传参问题之前的文章涉及过，在这里再次精练，python的实现方法是用实现，如果有一个，则表示多个参数的pack，如果函数定义和instance中各有一个*，则表示pack后的unpack。如下例：
def f(*args):
print(args)
f([1, 2, 3])
>>>([1, 2, 3],)
#因为def中有一个*，所以参数被pack成tuple
f(*[4, 5])
>>>(4, 5)
#因为def和instance中都有一个*，所以[4, 5]先被pack成([4, 5], )，再被unpack成(4, 5)
f(1, 2, 3)
>>>(1, 2, 3)
4.Dynamic Programming(DP)
课上Eric讲的words之间的distance不容易理解，这里替换为另一个例子。
假设一个游戏情境，你有一个袋子能够装一定重量的东西，给你一个机会去选择装一些商品，你的目的是尽可能装价值最高的组合。
现在有以下3件商品：
（1）音响，3000RMB，4斤
（2）笔记本电脑，2000RMB，3斤
（3）吉他，1500RMB，1斤
最简单的方式是穷举所有排列，找到价值最高符合条件的组合。但是上文的条件给出的是袋子的重量可变，多了一个参数后就很难用穷举固定答案，如果再加上其他变数，比如再加入新的商品，那么穷举不能解决类似问题，这个时候DP就派上了用场。
假设背包的承重是1-4斤，于是先考虑吉他，由于吉他只有1斤，四种情况最优解都是选择装吉他：
1斤 2斤 3斤 4斤
吉他 1500 1500 1500 1500
紧接着考虑音响的情况，由于音响重4斤，价值3000，所以4斤的情况改变选择，其他不变：
1斤 2斤 3斤 4斤
吉他 1500 1500 1500 1500
音响 1500 1500 1500 3000
随后再考虑电脑，电脑中3斤，所以1-2斤的情况不变，后两种情况要考虑新的最优解，3斤时应该选择电脑最合适，4斤的时候不是选择音响，而是选择3斤的电脑和1斤的吉他最合适：
1斤 2斤 3斤 4斤
吉他 1500 1500 1500 1500
音响 1500 1500 1500 3000
电脑 1500 1500 2000 3500
