[学习笔记] NumPy走一趟（持续更）

Numpy学习笔记

之前没有花时间去专门学Numpy，都是用到什么就草草查一下，最近在学DeepLearning，就决定还是系统地把Numpy学一遍。

一.Numpy基础篇

https://www.runoob.com/numpy/numpy-tutorial.html

大部分跟着菜鸟教程这个网站学的，上面有的基础知识点就不赘述了，只写一些值得特别注意的or没见过用法or自己的理解。

1.dtype（数据类型对象）

dt = np.dtype(np.int32)		#或np.dtype("i4")
print(dt)
#输出结果：int32

student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)

#输出结果：
#[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]

a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print(a)

#输出结果：
#[('abc', 21, 50.0), ('xyz', 18, 75.0)]

这个用法很像C语言里的结构体，先用np.dtype定义一个结构体里面的属性，然后用np.array实例化出很多对象，存在一个numpy数组里。

简单来说：创建了一个numpy-array数组，其中每个元素类型为之前定义好的dtype='student'。

2.ndarray.itemsize

ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。

# 数组的 dtype 为 int8（一个字节）
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)	#1

# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)	#8

3.numpy.arange

numpy.arange(start=0, stop, step=1, dtype)

（1）default：start=0，可以只传一参数这样用（结果为从0开始的n个数字）：

x = np.arange(5)
print (x)	#[0  1  2  3  4]

（2）stop不包含：再借用数学”黑话“，[start, stop) 是一个左闭右开区间。

（3）dtype：如果没有显示指定，则会使用输入数据的类型

4.numpy.linspace

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

默认包含stop

参数	描述
stop	序列的终止值，如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 ture 时，数列中中包含stop值，反之不包含，默认是True
retstep	如果为 True 时，生成的数组中会显示间距，反之不显示

a = np.linspace(1,10,10,retstep='true')
print(a)
#(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)

5.numpy.logspace

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

start：始于base的start次方

stop：终于base的stop次方

a = np.logspace(1,3,num=10)
print(a)
#array([  10.        ,   16.68100537,   27.82559402,   46.41588834,
#         77.42636827,  129.1549665 ,  215.443469  ,  359.38136638,
#        599.48425032, 1000.        ])
a = np.logspace(0,8,9,base=2)
print(a)
#array([  1.,   2.,   4.,   8.,  16.,  32.,  64., 128., 256.])

6.Numpy索引共享空间

a = np.arange(1,5)
print(a)	#[1 2 3 4]
b = a[1:3]
print(b)	#[2 3]
a[1]=999
print(b)	#[999 3]

7.Numpy高级索引

7.1整数数组索引

获取数组中(0,0)，(1,1)和(2,0)位置处的元素

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

numpy数组也可做索引

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

7.2布尔索引

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

7.3花式索引

花式索引不共享空间！而是将数据复制到新数组中

（1）传入索引数组

a = np.arange(32).reshape([8,4])
print(a)
#[[ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]
# [12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]
# [24 25 26 27]
# [28 29 30 31]]
b = a[ [4,2,1,7] ]
print(b)
# [[16 17 18 19]
#  [ 8  9 10 11]
#  [ 4  5  6  7]
#  [28 29 30 31]]

(2）传入多个索引数组（用np.ix_）

a[np.ix_([1,3],[2,5])]
返回数组 :
[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]

np.ix_:

得到两个数组的笛卡尔积

内部实际工作机制：

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

如果没有用np.ix_就变成了7.1 （1）中的数组索引，只返回a[1,4],a[2.5],a[3,6]组成的数组。

8.numpy.nditer

迭代对象numpy.nditer可以逐个访问数组元素

a = np.arange(6).reshape(2,3)
print(a)                                                                             # array([[0, 1, 2],
#        [3, 4, 5]])
for x in np.nditer(a):
	print(x,end=",")                                                                 # 0,1,2,3,4,5,
for x in np.nditer(a,order='F'):
    print(x,end=",")
# 0,3,1,4,2,5,

迭代访问的顺序并不是C-order(行优先)，而是和数组内存布局一致，这样做是为了提升访问的效率。

b = np.asarray(a,order='F')
print(b)
# array([[0, 1, 2],
#        [3, 4, 5]])
for x in np.nditer(b):
    print(x,end=",")
# 0,3,1,4,2,5,

关于转置在内存中的顺序：

c = a.T
print(c)
#[[0 3]
# [1 4]
# [2 5]]
for x in np.nditer(c):
	print(x,end=",")
# 0,1,2,3,4,5,

d = a.T.copy()
print(d)
#[[0 3]
# [1 4]
# [2 5]]
for x in np.nditer(d):
	print(x,end=",")
# 0,3,1,4,2,5,

另外c = a.T与a共享内存，而d = a.T.copy()真正的复制了一个矩阵。改变a的值，c会随之改变（反之，改c时a也会被改），而d不会改变。

若在遍历过程中想修改元素值：

for x in np.nditer(a, op_flags=['readwrite']):
#或
for x in np.nditer(a, op_flags=['write-only']):

#默认值 op_flags=read-only

二.函数艳遇篇

人们说，艳遇总是美好而短暂的，记录学习之旅中与各位函数的邂逅，想在脑海里留下些你们面容的残枝掠影～

行了，演不下去了，就是记点遇到的函数。

1.np.loadtxt()

作用：从.txt文件中读取数据存为数组。

M = np.loadtxt("test.txt")
#test.txt内容为：
#1 2 3
#4 5 6
print(M)
#[[1. 2. 3.]
# [4. 5. 6.]]

loadtxt自动处理换行符

M = np.loadtxt("test2.txt",delimiter=',')
#test2.txt内容为：
#1,2,3
#4,5,6
print(M)
#[[1. 2. 3.]
# [4. 5. 6.]]

delimiter指定.txt文件中元素的间隔符，默认为空格。当间隔符不是空格时必须显示指定。

2.numpy.nonzero

返回非零索引值

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

3.numpy.tile

就是把数组”平铺“得到新数组，这里讲的很明白：

https://blog.csdn.net/qq_18433441/article/details/54897250

三.实战技巧篇

1.乾坤大挪移（逆序数组...）

a = np.arange(5)
b = a[::-1]
print(a)	#[0 1 2 3 4]
print(b)	#[4 3 2 1 0]

a = np.arange(6).reshape(2,3)
b = a[::-1]
c = a[:,::-1]
d = a[::-1,::-1]
print(a)
print(b)
print(c)
print(d)
# [[0 1 2]
#  [3 4 5]]

# [[3 4 5]
#  [0 1 2]]

# [[2 1 0]
#  [5 4 3]]

# [[5 4 3]
#  [2 1 0]]

2.计算索引：numpy.unravel_index(indices, dims, order='C')

求第n个元素在数组中的（多维结构）索引。

也就是，已知平铺后的一维索引，求原多维结构的索引。

#求在7×8×9的多维数组中，第100个元素的索引
print(np.unravel_index(100,[7,8,9]))
#(1, 3, 1)

例如，常常这样用：

a = np.random.random([3,4])
a_max = a.argmax()
print(a)
print(a_max)
print(np.unravel_index(a_max,a.shape))
# [[0.32974103 0.62543059 0.5068712  0.20391591]
#  [0.24423194 0.24260907 0.40326733 0.31111273]
#  [0.28750882 0.67934444 0.5857911  0.67283181]]
# 9
# (2, 1)