Task01：预备知识

第一章 预备知识

一、Python基础

1. 列表推导式与条件赋值

在生成一个数字序列的时候，在 Python 中可以如下写出：

L = []
def my_func(x):
    return 2*x
for i in range(5):
    L.append(my_func(i))
L    
[0, 2, 4, 6, 8]

事实上可以利用列表推导式进行写法上的简化： [* for i in *] 。其中，第一个 * 为映射函数，其输入为后面 i 指代的内容，第二个 * 表示迭代的对象。

[my_func(i) for i in range(5)]
[0, 2, 4, 6, 8]

列表表达式还支持多层嵌套，如下面的例子中第一个 for 为外层循环，第二个为内层循环：

[m+'_'+n for m in ['a', 'b'] for n in ['c', 'd']]
['a_c', 'a_d', 'b_c', 'b_d']

除了列表推导式，另一个实用的语法糖是带有 if 选择的条件赋值，其形式为 value = a if condition else b ：

value = 'cat' if 2>1 else 'dog'
value
'cat'

等价于如下的写法：

a, b = 'cat', 'dog'
condition = 2 > 1 # 此时为True
if condition:
    value = a
else:
    value = b
value  
'cat'  

下面举一个例子，截断列表中超过5的元素，即超过5的用5代替，小于5的保留原来的值：

L = [1, 2, 3, 4, 5, 6, 7]
[i if i <= 5 else 5 for i in L]
[1, 2, 3, 4, 5, 5, 5]

2. 匿名函数与map方法
   有一些函数的定义具有清晰简单的映射关系，例如上面的 my_func 函数，这时候可以用匿名函数的方法简洁地表示：

my_func = lambda x: 2*x
my_func(3)
6

multi_para_func = lambda a, b: a + b
multi_para_func(1, 2)
3

但上面的用法其实违背了“匿名”的含义，事实上它往往在无需多处调用的场合进行使用，例如上面列表推导式中的例子，用户不关心函数的名字，只关心这种映射的关系：

[(lambda x: 2*x)(i) for i in range(5)]
[0, 2, 4, 6, 8]

对于上述的这种列表推导式的匿名函数映射， Python 中提供了 map 函数来完成，它返回的是一个 map 对象，需要通过 list 转为列表：

list(map(lambda x: 2*x, range(5)))
[0, 2, 4, 6, 8]

对于多个输入值的函数映射，可以通过追加迭代对象实现：

 list(map(lambda x, y: str(x)+'_'+y, range(5), list('abcde')))
 ['0_a', '1_b', '2_c', '3_d', '4_e']

3. zip对象与enumerate方法
   zip函数能够把多个可迭代对象打包成一个元组构成的可迭代对象，它返回了一个 zip 对象，通过 tuple, list 可以得到相应的打包结果：

L1, L2, L3 = list('abc'), list('def'), list('hij')
zip(L1, L2, L3)
<zip at 0x248990da188>
list(zip(L1, L2, L3))
[('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j')]
tuple(zip(L1, L2, L3))
(('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j'))

往往会在循环迭代的时候使用到 zip 函数：

for i, j, k in zip(L1, L2, L3):
      print(i, j, k)
a d h
b e i
c f j

enumerate 是一种特殊的打包，它可以在迭代时绑定迭代元素的遍历序号：

L = list('abcd')
for index, value in enumerate(L):
       print(index, value)
0 a
1 b
2 c
3 d

用 zip 对象也能够简单地实现这个功能：

for index, value in zip(range(len(L)), L):
        print(index, value)
0 a
1 b
2 c
3 d

当需要对两个列表建立字典映射时，可以利用 zip 对象：

dict(zip(L1, L2))
{'a': 'd', 'b': 'e', 'c': 'f'}

既然有了压缩函数，那么 Python 也提供了 * 操作符和 zip 联合使用来进行解压操作：

zipped = list(zip(L1, L2, L3))
zipped
[('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j')]

list(zip(*zipped)) # 三个元组分别对应原来的列表
[('a', 'b', 'c'), ('d', 'e', 'f'), ('h', 'i', 'j')]

二、Numpy基础

1. np数组的构造
   最一般的方法是通过 array 来构造：

import numpy as np
np.array([1,2,3])
array([1, 2, 3])

下面讨论一些特殊数组的生成方式：

【a】等差序列： np.linspace, np.arange

np.linspace(1,5,11) # 起始、终止（包含）、样本个数
array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ])

np.arange(1,5,2) # 起始、终止（不包含）、步长
array([1, 3])

【b】特殊矩阵： zeros, eye, full

np.zeros((2,3)) # 传入元组表示各维度大小
array([[0., 0., 0.],
       [0., 0., 0.]])

 np.eye(3) # 3*3的单位矩阵
 array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

np.eye(3, k=1) # 偏移主对角线1个单位的伪单位矩阵
array([[0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])

np.full((2,3), 10) # 元组传入大小，10表示填充数值
array([[10, 10, 10],
       [10, 10, 10]])

np.full((2,3), [1,2,3]) # 通过传入列表填充每列的值
array([[1, 2, 3],
       [1, 2, 3]])

【c】随机矩阵： np.random

最常用的随机生成函数为 rand, randn, randint, choice ，它们分别表示0-1均匀分布的随机数组、标准正态的随机数组、随机整数组和随机列表抽样：

np.random.rand(3) # 生成服从0-1均匀分布的三个随机数
array([0.66726108, 0.43001027, 0.26664002])

np.random.rand(3, 3) # 注意这里传入的不是元组，每个维度大小分开输入
array([[0.75982611, 0.36773113, 0.26006923],
       [0.73683057, 0.53157461, 0.12032781],
       [0.88817631, 0.60045601, 0.95509198]])

对于服从区间 a 到 b 上的均匀分布可以如下生成：

a, b = 5, 15
(b - a) * np.random.rand(3) + a
array([13.84195021,  5.22331243,  7.51948559])

randn 生成了 N(0,I) 的标准正态分布：

np.random.randn(3)
array([ 0.30371144, -1.56077538,  0.19187792])
np.random.randn(2, 2)
array([[ 0.27868423,  0.32838311],
       [-0.13123522, -0.08364785]])

对于服从方差为 σ2 均值为 μ 的一元正态分布可以如下生成：

sigma, mu = 2.5, 3
mu + np.random.randn(3) * sigma
array([-0.07345603,  1.39672295,  6.23457839])

randint 可以指定生成随机整数的最小值最大值（不包含）和维度大小：

low, high, size = 5, 15, (2,2) # 生成5到14的随机整数
np.random.randint(low, high, size)
array([[14,  8],
       [10, 10]])

choice 可以从给定的列表中，以一定概率和方式抽取结果，当不指定概率时为均匀采样，默认抽取方式为有放回抽样：

my_list = ['a', 'b', 'c', 'd']
np.random.choice(my_list, 2, replace=False, p=[0.1, 0.7, 0.1 ,0.1])
array(['b', 'a'], dtype='<U1')
np.random.choice(my_list, (3,3))
array([['d', 'b', 'a'],
       ['a', 'a', 'c'],
       ['c', 'b', 'a']], dtype='<U1')

当返回的元素个数与原列表相同时，等价于使用 permutation 函数，即打散原列表：

np.random.permutation(my_list)
array(['a', 'b', 'd', 'c'], dtype='<U1')

最后，需要提到的是随机种子，它能够固定随机数的输出结果：

np.random.seed(0)
np.random.rand()
0.5488135039273248
np.random.seed(0)
np.random.rand()
0.5488135039273248