numpy学习1

数据类型对象 (dtype)

numpy.dtype(object, align, copy)

object - 要转换为的数据类型对象
align - 如果为 true，填充字段使其类似 C 的结构体。
copy - 复制 dtype对象 ，如果为 false，则是对内置数据类型对象的引用。

import numpy as np
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i4')
print(dt)
int32

#定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象。
import numpy as np
student = np.dtype([('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)]

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。

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

reshape 函数来调整数组大小。

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

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，
numpy.empty(shape, dtype = float, order = ‘C’)，order有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

x = np.empty([3,2], dtype = int) 
[[ 6917529027641081856  5764616291768666155]
 [ 6917529027641081859 -5764598754299804209]
 [          4497473538      844429428932120]] #随机值

numpy.zeros=创建指定大小的数组，数组元素以 0 来填充。

# 默认为浮点数
x = np.zeros(5) 
print(x)
 
# 设置类型为整数
y = np.zeros((5,), dtype = np.int) 
print(y)
 
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print(z)

[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]

numpy.ones创建指定形状的数组，数组元素以 1 来填充。
numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
#num等步长的样本数量，默认为50

a = np.linspace(1,10,10) #设置起始点为 1 ，终止点为 10，数列个数为 10。
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
a = np.linspace(10, 20,  5, endpoint =  False)  # endpoint 设为 false，不包含终止值
[10. 12. 14. 16. 18.]
a =np.linspace(1,10,10,retstep= True)#如果retstep为 True 时，生成的数组中会显示间距，反之不显示。
(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)

NumPy 切片和索引

a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2，也可以下面这么写
s = a[2:7:2]   # 采用冒号切片， start:stop:step
[2  4  6]

[2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。顾头不顾尾！

a = np.arange(10)
print(a[2:])
[2  3  4  5  6  7  8  9]
print(a[2:5])
[2  3  4]

#多维数组
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a[1:])
[[3 4 5]
 [4 5 6]]

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
[2 4 5]
print (a[1,...])   # 第2行元素
[3 4 5]
print (a[...,1:])  # 第2列及剩下的所有元素
[[2 3]
 [4 5]
 [5 6]]

NumPy 高级索引

x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  #获取数组中(0,0)，(1,1)和(2,0)位置处的元素。
print (y)
[1  4  5]

#以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。
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]  
[[ 0  2]
 [ 9 11]]

#借助切片 : 或 … 与索引数组组合
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
[[5 6]
 [8 9]]
c = a[1:3,[1,2]]
[[5 6]
 [8 9]]
d = a[...,1:]
[[2 3]
 [5 6]
 [8 9]]

布尔索引：布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print (x[x >  5])  #获取大于 5 的元素
[ 6  7  8  9 10 11]

花式索引：根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。花式索引跟切片不一样，它总是将数据复制到新数组中。

#实例1
x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]])
[[16 17 18 19]   #第四行
 [ 8  9 10 11]    #第二行
 [ 4  5  6  7] #第一行
 [28 29 30 31]]#第七行
 ##传入多个索引数组（要使用np.ix_），实例2
 x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])])
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]
 #相当于
y=np.array([[x[1,0], x[1,3], x[1,1], x[1,2]],\
            [x[5,0], x[5,3], x[5,1],x[5,2]],\
            [x[7,0] ,x[7,3], x[7,1], x[7,2]],\
            [x[2,0], x[2,3], x[2,1], x[2,2]]])

NumPy 迭代数组

a = np.arange(6).reshape(2,3)
原始数组是：
[[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'):Fortran order，即是列序优先；
#for x in np.nditer(a.T, order='C'):C order，即是行序优先；a.T是a的转置
 for x in np.nditer(a.T.copy(order='C')):
    print (x, end=", " )
    #结果
    0, 3, 1, 4, 2, 5, 

修改数组形状 函数 描述 reshape 不改变数据的条件下修改形状 flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 ravel 返回展开数组

a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)
原始数组：
[0 1 2]
[3 4 5]
[6 7 8] 
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)
 迭代后的数组：
0
1
2
3
4
5
6
7
8
print (a.flatten()) #返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
[0 1 2 3 4 5 6 7]
print (a.ravel())
调用 ravel 函数之后：#修改会影响原始数组。
[0 1 2 3 4 5 6 7]

翻转数组 transpose 对换数组的维度 ndarray.T 和 self.transpose() 相同
rollaxis 向后滚动指定的轴 swapaxes 对换数组的两个轴

a = np.arange(12).reshape(3,4)
print ('原数组：')
print ('对换数组：')
print (np.transpose(a))
print ('转置数组：')
print (a.T)
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
对换数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
 转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

numpy.squeeze 函数从给定数组的形状中删除一维的条目

x = np.arange(9).reshape(1,3,3)
print ('数组 x：')
print (x)
y = np.squeeze(x)
print ('数组 y：')
数组 x：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]
数组 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]

连接数组
oncatenate 连接沿现有轴的数组序列,沿指定轴连接相同形状的两个或多个数组
stack 沿着新的轴加入一系列数组。
hstack 水平堆叠序列中的数组（列方向） vstack 竖直堆叠序列中的数组（行方向）

a = np.array([[1,2],[3,4]])
[[1 2]
 [3 4]]
b = np.array([[5,6],[7,8]])
[[5 6]
 [7 8]]
 #concatenate沿轴 0 连接两个数组：
print (np.concatenate((a,b)))
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
#concatenate沿轴 1 连接两个数组：
print (np.concatenate((a,b),axis = 1))
[[1 2 5 6]
 [3 4 7 8]]
 #stack沿轴 0 堆叠两个数组：
print (np.stack((a,b),0))
[[[1 2]
  [3 4]]
 [[5 6]
  [7 8]]]
 #stack沿轴 1 堆叠两个数组：
 print (np.stack((a,b),1))
[[[1 2]
  [5 6]]
 [[3 4]
  [7 8]]]
 # hstack 水平堆叠：
  c = np.hstack((a,b))
[[1 2 5 6]
 [3 4 7 8]]
#vstack竖直堆叠：
c = np.vstack((a,b))
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

==分割数组 ==
split 将一个数组分割为多个子数组
hsplit 将一个数组水平分割为多个子数组（按列）
vsplit 将一个数组垂直分割为多个子数组（按行）
格式：numpy.split(ary, indices_or_sections, axis)
参数说明：

ary：被分割的数组
indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分

a = np.arange(9)
[0 1 2 3 4 5 6 7 8] 
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])] 
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

harr = np.floor(10 * np.random.random((2, 6)))
#原array：
[[4. 7. 6. 3. 2. 6.]
 [6. 3. 6. 7. 9. 7.]]
 #hsplit水平分割，每行分割3个
print(np.hsplit(harr, 3))
[array([[4., 7.],
       [6., 3.]]), array([[6., 3.],
       [6., 7.]]), array([[2., 6.],
       [9., 7.]])]

a = np.arange(16).reshape(4,4)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
print ('竖直分割：')
b = np.vsplit(a,2)
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

== 数组元素的添加与删除 ==
resize 返回指定形状的新数组
append 将值添加到数组末尾
insert 沿指定轴将值插入到指定下标之前
delete 删掉某个轴的子数组，并返回删除后的新数组
unique 查找数组内的唯一元素

a = np.array([[1,2,3],[4,5,6]])
[[1 2 3]
 [4 5 6]]
b = np.resize(a, (3,2))
[[1 2]
 [3 4]
 [5 6]]
b = np.resize(a,(3,3)) #最后一行自动续上
[[1 2 3]
 [4 5 6]
 [1 2 3]]

a = np.array([[1,2,3],[4,5,6]])
[[1 2 3]
 [4 5 6]]
 #向数组添加元素：
print (np.append(a, [7,8,9]))
[1 2 3 4 5 6 7 8 9]
#沿轴 0 添加元素：
print (np.append(a, [[7,8,9]],axis = 0))
[[1 2 3]
 [4 5 6]
 [7 8 9]]
#沿轴 1 添加元素：
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

a = np.array([[1,2,3],[4,5,6]])
[[1 2 3]
 [4 5 6]]
 #未传递 Axis 参数。 在插入之前输入数组会被展开
 print (np.insert(a,3,[11,12]))
 [ 1  2  3 11 12  4  5  6]
 #沿轴 0 广播：按第二行添加一行，并广播
print (np.insert(a,1,[11],axis = 0))
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
#沿轴 1 广播： 在第二列添加一列
print (np.insert(a,1,11,axis = 1))
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]