Numpy库学习记录
迪丽瓦拉
2024-05-28 20:04:40
0次
文章目录
- 1 Numpy先知
- 2 Ndarray 对象
- 3 NumPy 数据类型
- 4 NumPy 数组属性
- 5 NumPy 创建数组
- 5.1 使用empty zeros ones创建
- 5.2 从已有的数组创建数组
- 5.3 从数值范围创建数组
- 6 切片和索引
1 Numpy先知
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
- 一个强大的N维数组对象 ndarray
- 广播功能函数
- 整合 C/C++/Fortran 代码的工具
- 线性代数、傅里叶变换、随机数生成等功能
2 Ndarray 对象
ndarray是N 维数，是NumPy 最重要的一个特点。它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
创建一个 ndarray 只需调用 NumPy 的 array 函数即可：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
示例：
#实例 1
import numpy as np
a = np.array([1,2,3])
print (a)#输出结果如下：
[1 2 3]#实例 2
# 多于一个维度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)#输出结果如下：
[[1 2] [3 4]]#实例 3
# 最小维度
import numpy as np
a = np.array([1, 2, 3, 4, 5], ndmin = 2)
print (a)#输出如下：(2维数组)
[[1 2 3 4 5]]#实例 4
# dtype 参数
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print (a)#输出结果如下：
[1.+0.j 2.+0.j 3.+0.j]
3 NumPy 数据类型
常用 NumPy 基本类型
| 名称 | 描述 |
|---|---|
| bool_ | 布尔型数据类型（True 或者 False） |
| int_ | 默认的整数类型（类似于 C 语言中的 long，int32 或 int64） |
| intc | 与 C 的 int 类型一样，一般是 int32 或 int 64 |
| intp | 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64） |
| int8 | 字节（-128 to 127） |
| int16 | 整数（-32768 to 32767） |
| int32 | 整数（-2147483648 to 2147483647） |
| int64 | 整数（-9223372036854775808 to 9223372036854775807） |
| uint8 | 无符号整数（0 to 255） |
| uint16 | 无符号整数（0 to 65535） |
| uint32 | 无符号整数（0 to 4294967295） |
| uint64 | 无符号整数（0 to 18446744073709551615） |
| float_ | float64 类型的简写 |
| float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 |
| float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 |
| float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 |
| complex_ | complex128 类型的简写，即 128 位复数 |
| complex64 | 复数，表示双 32 位浮点数（实数部分和虚数部分） |
| complex128 | 复数，表示双 64 位浮点数（实数部分和虚数部分） |
数据类型对象 (dtype)
numpy.dtype(object, align, copy)
| 属性 | 描述 |
|---|---|
| object | 要转换为的数据类型对象 |
| align | 如果为 true，填充字段使其类似 C 的结构体。 |
| copy | 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用 |
它描述了数据的以下几个方面：
- 数据的类型（整数，浮点数或者 Python 对象）
- 数据的大小（例如， 整数使用多少个字节存储）
- 数据的字节顺序（小端法或大端法）
- 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
- 如果数据类型是子数组，那么它的形状和数据类型是什么。
示例：
#实例 1
import numpy as np
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i4')
print(dt)#输出结果为：
int32#实例 2
import numpy as np
# 字节顺序标注
dt = np.dtype('4 NumPy 数组属性
- NumPy 数组的维数称为秩（rank），即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。
- axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。
- 在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。
NumPy 的数组中比较重要 ndarray 对象属性有：
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.real | ndarray元素的实部 |
| ndarray.imag | ndarray 元素的虚部 |
| ndarray.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
ndarray.ndim
ndarray.ndim 用于返回数组的维数，等于秩。
实例
import numpy as np
a = np.arange(24)
print (a.ndim) # a 现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3) # b 现在拥有三个维度
print (b.ndim)#输出结果为：
1
3
ndarray.shape
ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。
比如，一个二维数组，其维度表示"行数"和"列数"。
ndarray.shape 也可以用于调整数组大小。
实例
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)#输出结果为：
(2, 3)#调整数组大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print (a)#输出结果为：
[[1 2][3 4][5 6]]#NumPy 也提供了 reshape 函数来调整数组大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print (b)
输出结果为：[[1 2][3 4][5 6]]
ndarray.itemsize
ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。
例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。
实例
import numpy as np # 数组的 dtype 为 int8（一个字节）
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)#输出结果为：
1
8
5 NumPy 创建数组
ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。
5.1 使用empty zeros ones创建
numpy.empty
numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
numpy.empty(shape, dtype = float, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
下面是一个创建空数组的实例：
import numpy as np
x = np.empty([3,2], dtype = int)
print (x)#输出结果为：[[ 6917529027641081856 5764616291768666155][ 6917529027641081859 -5764598754299804209][ 4497473538 844429428932120]]
注意 − 数组元素为随机值，因为它们未初始化。
numpy.zeros
创建指定大小的数组，数组元素以 0 来填充：
numpy.zeros(shape, dtype = float, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
实例
import numpy as np# 默认为浮点数
x = np.zeros(5)
print(x)# 设置类型为整数
y = np.zeros((5,), dtype = 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.ones(shape, dtype = None, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
实例
import numpy as np# 默认为浮点数
x = np.ones(5)
print(x)# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)
输出结果为：[1. 1. 1. 1. 1.]
[[1 1][1 1]]
5.2 从已有的数组创建数组
numpy.asarray
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。
numpy.asarray(a, dtype = None, order = None)
参数说明：
| 参数 | 描述 |
|---|---|
| a | 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 |
| dtype | 数据类型，可选 |
| order | 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
#将列表转换为 ndarray:#实例
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print (a)#输出结果为：
[1 2 3]#将元组转换为 ndarray:#实例
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print (a)#输出结果为：
[1 2 3]#将元组列表转换为 ndarray:#实例
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print (a)#输出结果为：
[(1, 2, 3) (4, 5)]#设置了 dtype 参数：#实例
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print (a)#输出结果为：
[ 1. 2. 3.]
numpy.frombuffer
numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
注意：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。
参数说明：
| 参数 | 描述 |
|---|---|
| buffer | 可以是任意对象，会以流的形式读入。 |
| dtype | 返回数组的数据类型，可选 |
| count | 读取的数据数量，默认为-1，读取所有数据。 |
| offset | 读取的起始位置，默认为0。 |
Python3.x 实例
import numpy as np
s = b'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print (a)#输出结果为：
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
Python2.x 实例
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print (a)#输出结果为：
['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
numpy.fromiter
numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
numpy.fromiter(iterable, dtype, count=-1)
| 参数 | 描述 |
|---|---|
| iterable | 可迭代对象 |
| dtype | 返回数组的数据类型 |
| count | 读取的数据数量，默认为-1，读取所有数据 |
实例
import numpy as np # 使用 range 函数创建列表对象
list=range(5)
it=iter(list)# 使用迭代器创建 ndarray
x=np.fromiter(it, dtype=float)
print(x)#输出结果为：
[0. 1. 2. 3. 4.]
5.3 从数值范围创建数组
numpy.arange
numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
参数说明：
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
#生成 0 到 4 长度为 5 的数组:#实例
import numpy as np
x = np.arange(5)
print (x)#输出结果如下：
[0 1 2 3 4]#设置返回类型位 float:#实例
import numpy as np
#设置了 dtype
x = np.arange(5, dtype = float)
print (x)#输出结果如下：
[0. 1. 2. 3. 4.]#设置了起始值、终止值及步长：#实例
import numpy as np
x = np.arange(10,20,2)
print (x)#输出结果如下：
[10 12 14 16 18]
numpy.linspace
numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数说明：
| 参数 | 描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| dtype | ndarray 的数据类型 |
#以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。#实例
import numpy as np
a = np.linspace(1,10,10)
print(a)#输出结果为：
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]#设置元素全部是1的等差数列：#实例
import numpy as np
a = np.linspace(1,1,10)
print(a)#输出结果为：
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]#将 endpoint 设为 false，不包含终止值：#实例
import numpy as np
a = np.linspace(10, 20, 5, endpoint = False)
print(a)#输出结果为：
[10. 12. 14. 16. 18.]#如果将 endpoint 设为 true，则会包含 20。#以下实例设置间距。#实例
import numpy as np
a =np.linspace(1,10,10,retstep= True)
print(a)
#拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)#输出结果为：
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
[[ 1.][ 2.][ 3.][ 4.][ 5.][ 6.][ 7.][ 8.][ 9.][10.]]
numpy.logspace
numpy.logspace 函数用于创建一个等比数列。格式如下：
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base 参数意思是取对数的时候 log 的下标。
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
| base | 对数 log 的底数。 |
| dtype | ndarray 的数据类型 |
实例
import numpy as np
#默认底数是 10
a = np.logspace(1.0, 2.0, num = 10)
print (a)#输出结果为：
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402 35.93813664 46.41588834 59.94842503 77.42636827 100. ]#将对数的底数设置为 2 :#实例
import numpy as np
a = np.logspace(0,9,10,base=2)
print (a)#输出如下：
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
6 切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
实例
import numpy as np
a = np.arange(10)
s = slice(2,7,2) # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])#输出结果为：
[2 4 6]
也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
import numpy as np
a = np.arange(10)
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)#输出结果为：
[2 4 6]
冒号 : 的解释：
- 如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
- 如果为 [2:]，表示从该索引开始以后的所有项都将被提取。
- 如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
#实例
import numpy as np
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
b = a[5]
print(b)#输出结果为：
5#实例
import numpy as np
a = np.arange(10)
print(a[2:])#输出结果为：
[2 3 4 5 6 7 8 9]#实例
import numpy as np
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(a[2:5])#输出结果为：
[2 3 4]
多维数组同样适用上述索引提取方法：
实例
import numpy as npa = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
#从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])
输出结果为：[[1 2 3][3 4 5][4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5][4 5 6]]
切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray
实例
import numpy as npa = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
print (a[1,...]) # 第2行元素
print (a[...,1:]) # 第2列及剩下的所有元素
输出结果为：[2 4 5]
[3 4 5]
[[2 3][4 5][5 6]]
上一篇：顺序表（一篇带你掌握顺序表）
下一篇：关于分布式事务的理解