Numpy基础

ndarray 对象

numpy 定义了一个 ndarray 对象，表示一个多维数组，numpy 操作都是基于 ndarray 进行

使用 np.array 方法创建一个 ndarray 对象

1

np.array(object, dtype = None, copy = True, order = None, ndmin = 0)

• object：传入的序列对象，可以是列表或元组

• dtype：通过该参数设置数组的数据类型

• copy：设置该 ndarray 对象能否被复制

• order：设置数组的存储顺序，可选 C(行序列)，F(列序列)，A(默认)

• ndim：指定数组的维度

dtype 对象

dtype 对象用于描述数组元素的数据类型，大小和字节顺序

使用 np.dtype 方法创建一个 numpy 数据类型

1

numpy.dtype(object, align, copy)

• object：要转换为的数据类型对象
• align：如果为 true，则该类型使用字节对齐
• copy：复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

使用数据类型对象定义结构化数据，可以使 ndarray 实现字典的索引方式

1
2
3
4
5

import numpy as np
teacher = np.dtype([('name','S20'), ('age', 'i1'), ('salary', 'f4')])
#将其应用于ndarray对象
b = np.array([('ycs', 32, 6357.50),('jxe', 28, 6856.80)], dtype = teacher)
print(b['name']) # 字符串类型只支持ASCII

数组属性

以下是 ndarray 对象的一些常用属性

• ndarray.shape：返回一个以数组维度大小为元素的元组，从下标 0 到 n，可称为轴 0 到轴 n，可以直接设置该属性或使用 reshape 函数来改变维度

  1 2 3 4 5 6 7 8

  import numpy as np a = np.array([[1,2,3],[4,5,6]]) a.shape = (3,2) print (a) # 使用reshape函数，reshape函数不会创建副本，依然使用原来的引用，因此修改b元素，a元素也会改变 b = a.reshape(3,2) print (b)

• ndarray.ndim：返回数组的维度个数，即 shape 返回值的元素个数，该属性只读

• ndarray.itemsize：返回每个元素的字节大小

• ndarray.flags：返回数组的内存信息

• ndarray.size：数组的元素个数

• ndarray.dtype：数组的数据类型

创建数组

基本数组

• empty

  使用 np.empty() 创建一个未初始化的数组

  1	np.empty(shape, dtype = float, order = 'C')

  • shape：指定数组的形状，传入一个元组
  • dtype：指定数组的数据类型
  • order：指定数组的存储顺序，可选 C(行序列)，F(列序列)，A(默认)

• zeros

  使用 np.zeros() 创建一个所有值均为 0 的数组，参数同 empty()

• ones

  使用 np.zeros() 创建一个所有值均为 1 的数组，参数同 empty()

• asarray

  从已有的 ndarray 创建数组，与 array() 不同的是 array() 返回的是一个副本，asarray() 返回的是一个引用，原数组修改或返回的新数组修改都会改变数据

  1	numpy.asarray(a, dtype = None, order = None)

• frombuffer

  使用指定的缓冲区创建数组

  1	np.frombuffer(buffer, dtype = float, count = -1, offset = 0)

  • buffer：将任意对象转换为流的形式读入缓冲区
  • dtype：数组的数据类型，默认是 float32
  • count：要读取的数据数量，默认为 -1 表示读取所有数据
  • offset：读取数据的起始位置，默认为 0

• fromiter

  将可迭代对象转化为 ndarray 数组，返回一个一维数组

  1	np.fromiter(iterable, dtype, count = -1)

  • iterable：可迭代对象
  • dtype：数组的数据类型
  • count：读取的数据数量，默认为 -1，读取所有数据

区间数组

• arange

  指定一个数值范围创建 ndarray

  1	np.arange(start, stop, step, dtype)

  • start：起始数值
  • stop：终止值，范围为左闭右开
  • step：步长值，默认为 1
  • dtype：数据类型

• linspace

  创建等差数列 ndarray

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

  • start：数值区间的起始值
  • stop：数值区间的终止值
  • num：表示数值区间内要生成多少个均匀的样本。默认值为 50
  • endpoint：默认为 True，表示数列包含 stop 终止值，反之不包含
  • retstep：默认为 False，表示生成的数组中会显示公差（间距），反之不显示
  • dtype：数组元素值的数据类型

• logspace

  创建等比数列 ndarray

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

  • start，stop：起始值，终止值
  • num：生成的数组元素个数，默认为 50
  • endpoint：设置是否包含终止值，默认为 True
  • base：设置对数函数的底数，默认为 10
  • dtype：指定数组的数据类型

索引与切片

一维数组

使用内置函数 slice() 创建一个切片对象，再对 ndarray 切片

1
2
3
4

arr = np.arange(10)
s = slice(2, 7, 2)  # 创建切片对象
arr[s]  # 访问切片内容
# array([2, 4, 6])

使用 : 索引

对于一维数组，其基本格式为 [start:stop:step]，start 和 stop 为左闭右开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

arr[2:7:2]
# array([2, 4, 6])

arr[2:]  # 从[2]开始之后的所有项
# array([2, 3, 4, 5, 6, 7, 8, 9])

arr[:7]  # 在[7]之前的所有项，不包括[7]
# array([0, 1, 2, 3, 4, 5, 6])

arr[:]  # 等价于arr[::]，取当前维度所有项
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr[::2]  # 按步长切片
# array([0, 2, 4, 6, 8])

多维数组切片

使用 : 索引，按从外到内的顺序，对每一个维度进行切片，基本格式为 start:stop:step，不同维度用逗号隔开

1
2

arr[2:4, :] # 二维，取第三行和第四行
arr[:, 2:4] # 取第三列和第四列

使用省略号来表示某一维度的全索引，等价于 : 或 ::

1
2
3
4
5

# 二维
arr[2:4, ...] # 取第三行和第四行
arr[2, ...] # 取第三行
arr[..., 1:4] # 取第二列到第四列
arr[..., 1] # 取第二列

高级索引

numpy 不止可以通过单个整数索引，也可以通过其他方式来索引，主要有整数数组索引、布尔索引

整数数组索引

使用一个数组来索引另一个数组

1
2
3
4

x = np.array([[1,  2],  [3,  4],  [5,  6]])
# 行维度上访问[0, 1, 2]，列维度上访问[0, 1, 0]
# 对应组成坐标(0, 0), (1, 1), (2, 0)
x[[0, 1, 2],  [0, 1, 0]]  # [1  4  5]

索引数组的维度影响结果的维度

1
2
3
4
5
6
7

x = np.array([[1,  2],  [3,  4],  [5,  6]])
# 索引数组为一维，结果是一维
x[[0, 1, 2, 2], [0, 1, 0, 1]]  # array([1, 4, 5, 6])
# 索引数组为二维，则结果也是二维
x[[[0, 1], [2, 2]],  [[0, 1], [0, 1]]]
# array([[1, 4],
#        [5, 6]])

索引数组可以与 : 或 ... 配合

1
2
3
4

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

使用一个索引数组只访问一个维度

1
2
3
4

x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
x[[1, 2]]  # 一个数组只访问行维度
# array([[3, 4, 5],
#        [6, 7, 8]])

布尔索引

使用逻辑表达式进行索引

1
2
3

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

广播机制

广播机制用于解决不同形状的数组之间进行运算的问题

广播机制经过以下步骤

1. 补齐：以两个数组中的最大 ndim 值为准，其他数组在高维上（shape 元组左侧）补 1

   例如，a 数组的 shape 为 (4, 3)，b 数组的 shape 为 (3,)，则 b 数组补齐为 (1, 3)

2. 比较：依次比较两个数组的各个维度大小，若不相等且其中一个维度值不为 1，则报错

   例如，a 数组的 shape 为 (4, 3)，b 数组的 shape 为 (3, 1)，比较 shape[0] 时，不相等且其中一个值不为 1，报错

   例如，a 数组的 shape 为 (4, 3)，b 数组的 shape 为 (1, 3)

   • 比较 shape[0]，其中一个值为 1，通过
   • 比较 shape[1]，二者相等，通过

3. 扩展：在比较时，将维度大小为 1 的维度对应的元素复制多个，使其维度大小与另一数组对应维度大小相等

   例如，a 数组的 shape 为 (4, 3)，b 数组为 [[0, 1, 2]]，shape 为 (1, 3)，维度大小为 1 维度对应的元素为 [0, 1, 2]，复制该元素，将维度大小扩展到 4，即 b 数组变为 [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]，shape 变为 (4, 3)

4. 运算：两个数组经过以上处理后，若 shape 相同，则可以运算

e.g. x = [0, 1, 2], y = [[0], [1], [2]]

• x 的 shape 为 (1, 3)，扩展为 (3, 3)，数组变为 [[0, 1, 2], [0, 1, 2], [0, 1, 2]]
• y 的 shape 为 (3, 1)，扩展为 (3, 3)，数组变为 [[0, 0, 0], [1, 1, 1], [2, 2, 2]]

1
2
3
4
5
6
7

x = np.array([0, 1, 2])
y = np.array([0, 1, 2])
y = y.reshape((3, 1))
x + y
# array([[0, 1, 2],
#        [1, 2, 3],
#        [2, 3, 4]])

遍历数组

使用 numpy 的 nditer 迭代器对象，配合 for 进行遍历，迭代器的遍历顺序与数组的存储顺序一致

1
2
3
4
5
6
7

import numpy as np
a = np.arange(0, 60, 5)
a = a.reshape(3, 4)
# 使用nditer迭代器,并使用for进行遍历
# 若传入a.T，存储顺序不改变，依然按行序遍历
for x in np.nditer(a):
   print(x)

• order：指定迭代器的遍历顺序
• op_flags：表示能否在遍历时修改数据，默认为 readonly，可选 readwrite，writeonly

遍历多个数组时，可以触发广播机制

1
2
3
4
5
6
7
8
9
10

import numpy as np
a = np.arange(0, 60, 5)
a = a.reshape(3, 4)
print (a)
b = np.array([1, 2, 3, 4], dtype = int)
print (b） 
# 广播迭代
for x,y in np.nditer([a,b]): # 传入两个数组组成的列表
    print ("%d:%d" % (x,y),end=",")
# 0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4

数组操作

展平

轴操作

维度操作

连接数组

分割数组

元素修改

位运算

字符串处理

字符串处理函数定义在 numpy.char 类中，函数的处理对象是 dtype 为 string_ 或 unicode_ 的字符串数组

数学函数

三角函数

舍入函数

算术运算

统计函数

排序和搜索

IO 操作

numpy 中提供了一些 IO 函数，用于在文件中读写 ndarray 对象

可操作的文件类型

• .npy 文件
• .txt 文件
• .npz 文件