Autoleaders算法组——numpy学习笔记

 1，数组创建

【1】numpy.array()

​
a=numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

​

创建一个数组a

dtype用于指定数据类型

copy为对象是否被复制（bool)

order C（按行）、F（按列）或A（任意，默认）

subok 默认情况下，返回的数组被强制为基类数组

ndmin 指定a的最小维数

a

1.	bool_ 存储为一个字节的布尔值（真或假）
2.	int_ 默认整数，相当于 C 的long，通常为int32或int64
3.	intc 相当于 C 的int，通常为int32或int64
4.	intp 用于索引的整数，相当于 C 的size_t，通常为int32或int64
5.	int8 字节（-128 ~ 127）
6.	int16 16 位整数（-32768 ~ 32767）
7.	int32 32 位整数（-2147483648 ~ 2147483647）
8.	int64 64 位整数（-9223372036854775808 ~ 9223372036854775807）
9.	uint8 8 位无符号整数（0 ~ 255）
10.	uint16 16 位无符号整数（0 ~ 65535）
11.	uint32 32 位无符号整数（0 ~ 4294967295）
12.	uint64 64 位无符号整数（0 ~ 18446744073709551615）
13.	float_ float64的简写
14.	float16 半精度浮点：符号位，5 位指数，10 位尾数
15.	float32 单精度浮点：符号位，8 位指数，23 位尾数
16.	float64 双精度浮点：符号位，11 位指数，52 位尾数
17.	complex_ complex128的简写
18.	complex64 复数，由两个 32 位浮点表示（实部和虚部）
19.	complex128 复数，由两个 64 位浮点表示（实部和虚部）

 【2】生成全为0的数组

x = np.zeros((2,2), dtype =  [('x',  'i4'),  ('y',  'i4')])  
print x

【3】生成全为1的数组

x = np.ones(5)  
print x

【4】生成连续自然数数组（图例生成的是[0,1,2,3,4])

x = np.arange(5)  
print x

 【5】生成首项和最后一项以及项数都已知的等差数列

numpy.linspace(start, stop, num, endpoint, retstep, dtype）

1.	start 序列的起始值
2.	stop 序列的终止值，如果endpoint为true，该值包含于序列中
3.	num 要生成的等间隔样例数量，默认为50
4.	endpoint 序列中是否包含stop值，默认为ture
5.	retstep 如果为true，返回样例，以及连续数字之间的步长
6.	dtype 输出ndarray的数据类型

x = np.linspace(10,20,5)  
print x

 

2，数组的处理

【1】改变维度，图例把原本的a变为3行2列的数组

a = np.array([[1,2,3],[4,5,6]]) a.shape =  (3,2)  
print a

 【2】查询，处理数组的元素

①切片查

[1]一维

a = np.arange(10)
b = a[2:7:2]  
print b

[2]二维

查一行(图例得到第二行[3,4,5]）

a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print a[1]

查一行的一个(要基于查一行进行，即先查行再查列）

x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print y

查一行的一个涉及到高级索引，y = x[[0,1,2],  [0,1,0]]  存在对应关系，左边的0对应右边的0，即查询第0行的第0个，得到1，前面的是行，后边的是列。

②用布尔索引查是否符合条件的元素

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])

print x[x >  5]

此例查询大于5的

a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print a[~np.isnan(a)]

此例用于查询 不为 NaN的元素（~是取补，搭配后面的isnan就是取NaN以外的元素）

a = np.array([1,  2+6j,  5,  3.5+5j])  
print a[np.iscomplex(a)]

此例为查询类型为复数的元素

③数组计算

[1]数组整体与数组整体的加减乘除

a = np.arange(9, dtype = np.float_).reshape(3,3)  
print  '第一个数组：'  
print a 
print  '\n'  
print  '第二个数组：' 
b = np.array([10,10,10])  
print b 
print  '\n'  
print  '两个数组相加：'  
print np.add(a,b)  
print  '\n'  
print  '两个数组相减：'  
print np.subtract(a,b)  
print  '\n'  
print  '两个数组相乘：'  
print np.multiply(a,b)  
print  '\n'  
print  '两个数组相除：'  
print np.divide(a,b)

第一个数组：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]
 
第二个数组：
[10 10 10]
 
两个数组相加：
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]
 
两个数组相减：
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]
 
两个数组相乘：
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]
 
两个数组相除：
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]

 [2]数组内的整行或整列计算（用于二维及以上）,此处axis为整条0轴/整条1轴/整条2轴...后面讲广播时会说。

a = np.sum([[0,4],[2,6]],axis=0)
print(a)

 ④逐个元素比较大小,获取最大值

X = np.array([1, 2, 3, 4])
Y = np.array([4, 3, 1, 3])
print(np.maximum(X, Y))
>>> [4 3 3 4]

 ⑤返回众数

counts=np.bincount(a)
print(np.argmax(counts))

 np.bincount可以返回所有元素的出现次数，np.argmax可以返回出现次数最多的数（即众数）对应的位置

⑥修改数据

a = np.arange(10)
print(a)
aaa = np.where(a > 5, 1, -1)
print(aaa)

[0 1 2 3 4 5 6 7 8 9]
[-1 -1 -1 -1 -1 -1  1  1  1  1]

 np.where()第一个参数为条件，第二个参数为条件成立则修改的值，第三个参数为条件不成立修改的值。

引申应用：把符合条件的改为1，不符合改为0，然后全部加起来得到符合条件的元素数目。

⑦数组排序

a = np.array([[1, 5, 4, 8, 4],
              [2, 4, 7, 1, 5],
              [1, 0, 3, 4, 2]])
a1 = np.sort(a)
a2 = np.sort(a, axis=1)  
a3 = np.sort(a, axis=0)  
print(a1)
print(a2)
print(a3)

[[1 4 4 5 8]
 [1 2 4 5 7]
 [0 1 2 3 4]]
 
[[1 4 4 5 8]
 [1 2 4 5 7]
 [0 1 2 3 4]]
 
[[1 0 3 1 2]
 [1 4 4 4 4]
 [2 5 7 8 5]]

np.sort()第二个参数为顺着哪条轴进行升序排列

⑧ 检查在某个数组内的元素

test = np.array([0, 1, 2, 5, 0])
states = [0, 2]
mask = np.in1d(test, states)
print(mask)
print(test[mask])

得到

[ True False  True False  True]
[0 2 0]

 下面用到了布尔索引，提取出了符合条件的元素

3，广播 

如果两个数组行数列数均相同，则可直接计算

a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print(c)

图例得到的[10，40，90，160]

如果行数列数不等呢？

“线动成面，面动成体”

线是一维（1条轴），面是二维（2条轴），体是三维（3条轴）

对原本”线“唯一的一条轴，我们定为0轴。线动成面的过程中“创建”了一条轴，这条便是二维的0轴，那原本”线“的0轴呢？变成了1轴。面动成体的过程中又“创建”了一条轴，这条便是三维的0轴，那原本”面“的0轴，1轴呢？0轴（原）变成了1轴，1轴（原）变成了2轴。

假定我们现在有两个数组，a(一维)和b(二维)。

a的0轴是3，b的0轴(z方向坐标）为6，1轴为4，2轴为3，那a就会变成4*3*6的数组，然后跟b进行一系列操作。

4，数组迭代

a = np.arange(0,60,5) 
a = a.reshape(3,4) 
for i in np.nditer(a):
    print(i)

【1】迭代顺序

a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始数组是：'  
print a print  '\n'  
print  '原始数组的转置是：' 
b = a.T 
print b 
print  '\n'  
print  '以 C 风格顺序排序：' 
c = b.copy(order='C')  
print c for x in np.nditer(c):  
    print x,  
print  '\n'  
print  '以 F 风格顺序排序：' 
c = b.copy(order='F')  
print c 
for x in np.nditer(c):  
    print x

以下为输出结果

原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
 
原始数组的转置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
 
以 C 风格顺序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
 
以 F 风格顺序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

由此可见，风格不同迭代顺序也有所不同

当然，也可以在for 循环处指定迭代顺序

for x in np.nditer(a, order =  'C'):  
    print x

【2】通过迭代修改元素

import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始数组是：'  
print a 
print  '\n'  
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x 
print  '修改后的数组是：' 
print a

原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
 
修改后的数组是：
[[ 0 10 20 30]
 [ 40 50 60 70]
 [ 80 90 100 110]]