一. python简介
1. python 具有丰富强大的库，常被称为胶水语言，能够把用其他语言制作的各种模块很轻松地联结在一起
2. python强制使用空白符（white space）作为语句缩进。
3. 可以使用 py2exe等包转换成系统能够执行的文件。
4. Python的瓶颈不在于自身语言的运行时间，在于一些网络速度等外在因素的影响。
二. Python库
1. python版本
常用的有2.7和3.5两个版本，这两个版本不完全兼容。但就目前Windows的环境而言，Python2.7对于数据分析领域就足够用了，但3.5更多用于web开发。当然，也可以使用 2to3.py 实现两个版本之间的转换。
D:>python 2to3.py t1.py RefactoringTool: Skipping optional fixer: buffer RefactoringTool: Skipping optional fixer: idioms RefactoringTool: Skipping optional fixer: set_literal RefactoringTool: Skipping optional fixer: ws_comma RefactoringTool: Refactored t1.py --- t1.py (original) +++ t1.py (refactored) @@ -1 +1 @@ -print 'all tasks has been finished!' +print('all tasks has been finished!') RefactoringTool: Files that need to be modified: RefactoringTool: t1.py
不推荐大家使用上面这个转换的库，因为官网上说这个库会随着时间发生剧烈的变化。
2. pip
pip是安装python包的推荐工具：https://pypi.python.org/pypi/pip
也可以手动更换pip中的数据源：pip install -l https://pypi.tuna.tsinghua.edu.cn/simple numpy
pip会在数据源中查找符合你系统配置的最新版的安装包进行自动安装。
3. numpy
为Python提供快速的多维数组处理能力
4. pandas
在numpy基础上提供了更多了数据读写工具
5. scipy
在numpy基础上添加了众多科学计算工具包
6.matplotlib
Python丰富的绘图库，主要针对二维绘图，有少数的三维绘图函数
三. 数据生成
1. list, array
标准Python的列表list中，元素本质是对象
如：L=[1,2,3],需要3个指针和三个整数对象，对于数值运算比较浪费内存和CPU。
因此，numpy提供了ndarray(N-dimensional array object)对象:存储单一数据类型的多维数组。
# # 1.使用array创建 # 通过array函数传递list对象 L = [1, 2, 3, 4, 5, 6] print "L = ", L a = np.array(L)
print "a = ", a
print type(a), type(L)
# # 若传递的是多层嵌套的list，将创建多维数组
b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print b
2. 改变数组的大小和形状
# # # # # 数组大小可以通过其shape属性获得 print a.shape print b.shape # # # # 也可以强制修改shape b.shape = 4, 3 print b # # 注：从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没有改变 # # # # 当某个轴为-1时，将根据数组元素的个数自动计算此轴的长度 b.shape = 2, -1 print b print b.shape # b.shape = 3, 4 print b # # # # 使用reshape方法，可以创建改变了尺寸的新数组，原数组的shape保持不变 c = b.reshape((4, -1)) print "b = ", b print 'c = ', c
3. 数组的存储，类型
# # # # 数组b和c共享内存，修改任意一个将影响另外一个 b[0][1] = 20 print "b = ", b print "c = ", c # # # # # 数组的元素类型可以通过dtype属性获得 print a.dtype print b.dtype # # # # # # # # # # 可以通过dtype参数在创建时指定元素类型 d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float) f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex) print d print f # # # # 如果更改元素类型，可以使用astype安全的转换 f = d.astype(np.int) print f # # # # # # # 但不要强制仅修改元素类型，如下面这句，将会以int来解释单精度float类型 d.dtype = np.int print d下面是上面代码中倒数第二个d, 和f的输出
[[ 1. 2. 3. 4.] [ 5. 6. 7. 8.] [ 9. 10. 11. 12.]] [[ 1.+0.j 2.+0.j 3.+0.j 4.+0.j] [ 5.+0.j 6.+0.j 7.+0.j 8.+0.j] [ 9.+0.j 10.+0.j 11.+0.j 12.+0.j]]
4. 使用函数创建
# 如果生成一定规则的数据，可以使用NumPy提供的专门函数 # arange函数类似于python的range函数：指定起始值、终止值和步长来创建数组 # 和Python的range类似，arange同样不包括终值；但arange可以生成浮点类型，而range只能是整数类型 np.set_printoptions(linewidth=100, suppress=True) a = np.arange(1, 10, 0.5) print a # # # # linspace函数通过指定起始值、终止值和元素个数来创建数组，缺省包括终止值 b = np.linspace(1, 10, 10) print 'b = ', b # # 可以通过endpoint关键字指定是否包括终值 c = np.linspace(1, 10, 10, endpoint=False) print 'c = ', c # # # 和linspace类似，logspace可以创建等比数列 # # 下面函数创建起始值为10^1，终止值为10^2，有10个数的等比数列 d = np.logspace(1, 4, 4, endpoint=True, base=2) print d # # # # # # # # # # 下面创建起始值为2^0，终止值为2^10(包括)，有10个数的等比数列 f = np.logspace(0, 10, 11, endpoint=True, base=2) print f # # # # # 使用 frombuffer, fromstring, fromfile等函数可以从字节序列创建数组 s = 'abcdzzzz' g = np.fromstring(s, dtype=np.int8) print g # #
下面为输出结果：
[ 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5] b = [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.] c = [ 1. 1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1] [ 2. 4. 8. 16.] [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.] [ 97 98 99 100 122 122 122 122]
5. 存取
1）常规办法
# 数组元素的存取方法和Python的标准方法相同 a = np.arange(10) print a # # # 获取某个元素 print a[3] # # # # # 切片[3,6)，左闭右开 print a[3:6] # # # 省略开始下标，表示从0开始 print a[:5] # # # 下标为负表示从后向前数 print a[3:] # # 步长为2 print a[1:9:2] # # # # # # 步长为-1，即翻转 print a[::-1] # # 切片数据是原数组的一个视图，与原数组共享内容空间，可以直接修改元素值 a[1:4] = 10, 20, 30 print a # # 因此，在实践中，切实注意原始数据是否被破坏，如： b = a[2:5] b[0] = 200 print a
[0 1 2 3 4 5 6 7 8 9] 3 [3 4 5] [0 1 2 3 4] [3 4 5 6 7 8 9] [1 3 5 7] [9 8 7 6 5 4 3 2 1 0] [ 0 10 20 30 4 5 6 7 8 9] [ 0 10 200 30 4 5 6 7 8 9]
2）整数/布尔数组存取
# 3.2.1 # 根据整数数组存取：当使用整数序列对数组元素进行存取时， # 将使用整数序列中的每个元素作为下标，整数序列可以是列表(list)或者数组(ndarray)。 # 使用整数序列作为下标获得的数组不和原始数组共享数据空间。 a = np.logspace(0, 9, 10, base=2) print a i = np.arange(0, 10, 2) print i # # # 利用i取a中的元素 b = a[i] print b # # # b的元素更改，a中元素不受影响 b[2] = 1.6 print b print a # # 3.2.2 # 使用布尔数组i作为下标存取数组a中的元素：返回数组a中所有在数组b中对应下标为True的元素 # 生成10个满足[0,1)中均匀分布的随机数 a = np.random.rand(10) print a # # 大于0.5的元素索引 print a > 0.5 # # # 大于0.5的元素 b = a[a > 0.5] print b # # # 将原数组中大于0.5的元素截取成0.5 a[a > 0.5] = 0.5 print a # # # # # b不受影响 print b
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.] [0 2 4 6 8] [ 1. 4. 16. 64. 256.] [ 1. 4. 1.6 64. 256. ] [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.] [ 0.6863079 0.43770902 0.06801346 0.75436358 0.94302857 0.79214232 0.08905118 0.50204237 0.20263459 0.67341405] [ True False False True True True False True False True] [ 0.6863079 0.75436358 0.94302857 0.79214232 0.50204237 0.67341405] [ 0.5 0.43770902 0.06801346 0.5 0.5 0.5 0.08905118 0.5 0.20263459 0.5 ] [ 0.6863079 0.75436358 0.94302857 0.79214232 0.50204237 0.67341405]
3)切片
# 3.3 二维数组的切片 # [[ 0 1 2 3 4 5] # [10 11 12 13 14 15] # [20 21 22 23 24 25] # [30 31 32 33 34 35] # [40 41 42 43 44 45] # [50 51 52 53 54 55]] a = np.arange(0, 60, 10) # 行向量 print 'a = ', a b = a.reshape((-1, 1)) # 转换成列向量 print b c = np.arange(6) print c f = b + c # 行 + 列 print f # # 合并上述代码： a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6) print a # # # 二维数组的切片 print '++++++++++++++' print a[[0, 1, 2], [2, 3, 4]] print a[4, [2, 3, 4]] print a[4:, [2, 3, 4]] print '+++++++++++++' i = np.array([True, False, True, False, False, True]) print i print a[i] print a[i, 3]
a = [ 0 10 20 30 40 50] [[ 0] [10] [20] [30] [40] [50]] [0 1 2 3 4 5] [[ 0 1 2 3 4 5] [10 11 12 13 14 15] [20 21 22 23 24 25] [30 31 32 33 34 35] [40 41 42 43 44 45] [50 51 52 53 54 55]] [[ 0 1 2 3 4 5] [10 11 12 13 14 15] [20 21 22 23 24 25] [30 31 32 33 34 35] [40 41 42 43 44 45] [50 51 52 53 54 55]] ++++++++++++++ [ 2 13 24] [42 43 44] [[42 43 44] [52 53 54]] +++++++++++++ [ True False True False False True] [[ 0 1 2 3 4 5] [20 21 22 23 24 25] [50 51 52 53 54 55]] [ 3 23 53]
上面代码中，
a[i]中索引 i 因为是布尔数组，所以它实际上是对对应行的选择，TRUE为选择，FALSE为不选择。
6.numpy与Python数学库的时间比较
for j in np.logspace(0, 7, 8): x = np.linspace(0, 10, j) start = time.clock() y = np.sin(x) t1 = time.clock() - start x = x.tolist() start = time.clock() for i, t in enumerate(x): x[i] = math.sin(t) t2 = time.clock() - start print j, ": ", t1, t2, t2/t1
1.0 : 8.00000000001e-06 9.00000000015e-06 1.12500000002 10.0 : 0.000125 0.000319 2.552 100.0 : 1.20000000001e-05 0.000231 19.2499999998 1000.0 : 0.000138 0.000307 2.22463768116 10000.0 : 0.000383 0.002946 7.69190600522 100000.0 : 0.003997 0.029284 7.32649487115 1000000.0 : 0.038909 0.326851 8.40039579532 10000000.0 : 0.390234 2.951487 7.5633773582
从上面的运行结果可以看出来，一般情况下，numpy的效率比Python数学库要快，平均快7倍左右
7. 元素去重
# 4.2 元素去重 # 4.2.1直接使用库函数 a = np.array((1, 2, 3, 4, 5, 5, 7, 3, 2, 2, 8, 8)) print '原始数组：', a # # # 使用库函数unique b = np.unique(a) print '去重后：', b # # 4.2.2 二维数组的去重，结果会是预期的么？ c = np.array(((1, 2), (3, 4), (5, 6), (1, 3), (3, 4), (7, 6))) print '二维数组： ', c print '去重后：', np.unique(c) # # # 4.2.3 方案1：转换为虚数 r, i = np.split(c, (1, ), axis=1) x = r + i * 1j x = c[:, 0] + c[:, 1] * 1j print '转换成虚数：', x print '虚数去重后：', np.unique(x) print np.unique(x, return_index=True) # 思考return_index的意义 idx = np.unique(x, return_index=True)[1] print '二维数组去重： ', c[idx] # # 4.2.3 方案2：利用set print '去重方案2： ', np.array(list(set([tuple(t) for t in c])))原始数组： [1 2 3 4 5 5 7 3 2 2 8 8]
去重后： [1 2 3 4 5 7 8] 二维数组： [[1 2] [3 4] [5 6] [1 3] [3 4] [7 6]] 去重后： [1 2 3 4 5 6 7] 转换成虚数： [ 1.+2.j 3.+4.j 5.+6.j 1.+3.j 3.+4.j 7.+6.j] 虚数去重后： [ 1.+2.j 1.+3.j 3.+4.j 5.+6.j 7.+6.j] (array([ 1.+2.j, 1.+3.j, 3.+4.j, 5.+6.j, 7.+6.j]), array([0, 3, 1, 2, 5])) 二维数组去重： [[1 2] [1 3] [3 4] [5 6] [7 6]] 去重方案2： [[1 2] [5 6] [7 6] [1 3] [3 4]]
从上面输出结果可以看出：
a. 直接使用np.unique(c)为二维数组去重，不能达到理想的结果。因为unique会默认将输入的数组拉成一维的，然后去重。
b. 对于二维数组去重，一般会选择先将其转成虚数去重，然后再还原成二维。但该种方式会打乱数组里面元素的顺序，所以我们可以令参数return_index=true来让其放回各个元素原始的索引。
c. 使用set来去重需要先将数组转成list然后再进行操作。
8.三维数组去重
# 4.3 stack and axis a = np.arange(1, 7).reshape((2, 3)) b = np.arange(11, 17).reshape((2, 3)) c = np.arange(21, 27).reshape((2, 3)) d = np.arange(31, 37).reshape((2, 3)) print 'a = ', a print 'b = ', b print 'c = ', c print 'd = ', d s = np.stack((a, b, c, d), axis=0) print 'axis = 0 ', s.shape, ' ', s s = np.stack((a, b, c, d), axis=1) print 'axis = 1 ', s.shape, ' ', s s = np.stack((a, b, c, d), axis=2) print 'axis = 2 ', s.shape, ' ', s a = np.arange(1, 10).reshape(3,3) print a b = a + 10 print b print np.dot(a, b) ###矩阵乘法 print a * b ##矩阵元素相乘 a = np.arange(1, 10) print a b = np.arange(20,25) print b print np.concatenate((a, b)) ###连接
a = [[1 2 3] [4 5 6]] b = [[11 12 13] [14 15 16]] c = [[21 22 23] [24 25 26]] d = [[31 32 33] [34 35 36]] axis = 0 (4, 2, 3) [[[ 1 2 3] [ 4 5 6]] [[11 12 13] [14 15 16]] [[21 22 23] [24 25 26]] [[31 32 33] [34 35 36]]] axis = 1 (2, 4, 3) [[[ 1 2 3] [11 12 13] [21 22 23] [31 32 33]] [[ 4 5 6] [14 15 16] [24 25 26] [34 35 36]]] axis = 2 (2, 3, 4) [[[ 1 11 21 31] [ 2 12 22 32] [ 3 13 23 33]] [[ 4 14 24 34] [ 5 15 25 35] [ 6 16 26 36]]] [[1 2 3] [4 5 6] [7 8 9]] [[11 12 13] [14 15 16] [17 18 19]] [[ 90 96 102] [216 231 246] [342 366 390]] [[ 11 24 39] [ 56 75 96] [119 144 171]] [1 2 3 4 5 6 7 8 9] [20 21 22 23 24] [ 1 2 3 4 5 6 7 8 9 20 21 22 23 24]
函数stack实现多个数组堆叠的功能。从运行结果可以看出，当
axis=0时， 是将a, b, c, d四个数组分别作为元素组成新的列向量中的元素；
axis=1时，是分别将a, b, c, d四个数组中的第一个元素组成一个新的列元素，第二个元素也是同样的，最后组成一个列向量。
axis=2时，是将a,b,c,d四个数组先拉成一维，然后分别取四个数组中相同位置的元素组成新的列向量中的元素。