HarshLog

Nothing Is Written

0%

Numpy笔记

发表于 分类于
NumPy 是一个运行速度非常快的数学库，主要用于数组计算

安装

1
pip3 install --user numpy scipy matplotlib

Ndarray 对象

 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

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

参数说明：

名称 描述
object 数组或嵌套的数列
dtype 数组元素的数据类型，可选
copy 对象是否需要复制，可选
order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok 默认返回一个与基类类型一致的数组
ndmin 指定生成数组的最小维度 
1
2
3
4
5
6
import numpy as np 
a = np.array([1,2,3],ndmin =  2,dtype = complex,)  
print (a)
/*

*/

数据类型

名称 描述
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 位浮点数（实数部分和虚数部分）

numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

数据类型对象 (dtype)

1
numpy.dtype(object, align, copy)
1
2
3
4
import numpy as np
# 使用标量类型
dt = np.dtype(np.int32)
print(dt)    
1
2
3
4
5
6
import numpy as np
dt = np.dtype([('age',np.int8)]) 
print(dt)     
/*
[('age', 'i1')]    
*/
1
2
3
4
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)

数组属性

属性 说明
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 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性

创建数组

numpy.empty

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

numpy.zeros

1
numpy.zeros(shape, dtype = float, order = 'C')

numpy.ones

1
numpy.ones(shape, dtype = None, order = 'C')

从已有的数组创建数组

numpy.asarray

1
numpy.asarray(a,dtype = None, order = None)
参数 描述
a 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype 数据类型，可选
order 可选，有”C”和”F”两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 
1
2
3
4
5
import numpy as np 

x =  [1,2,3] 
a = np.asarray(x)  
print (a)

numpy.frombuffer

1
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
1
2
3
4
import numpy as np 
s =  b'Hello World' 
a = np.frombuffer(s, dtype =  'S1')  
print (a)

numpy.fromiter

1
numpy.fromiter(iterable, dtype, count=-1)
1
2
3
4
5
6
7
8
9
import numpy as np 

# 使用 range 函数创建列表对象  
list=range(5)
it=iter(list)

# 使用迭代器创建 ndarray 
x=np.fromiter(it, dtype=float)
print(x)

从数值范围创建数组

numpy.arange

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

numpy.linspace

1
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 的数据类型

numpy.logspace

1
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
参数 描述
start 序列的起始值为：base ** start
stop 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
base 对数 log 的底数。
dtype ndarray 的数据类型

切片和索引

1
2
3
4
5
6
7
8
import numpy as np

a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])    
/*
[2  4  6]
*/
1
2
3
4
5
import numpy as np

a = np.arange(10)  
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)

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

1
2
3
4
5
6
import numpy as np

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

高级索引

整数数组索引

1
2
3
4
5
import numpy as np 
 #以下实例获取数组中 (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
2
3
4
5
6
7
8
9
import numpy as np 

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素  
print  ('大于 5 的元素是：')
print (x[x >  5])

花式索引

1
2
3
4
5
6
7
8
9
10
11
mport numpy as np

x = np.arange(9)
print(x)
# 一维数组读取指定下标对应的元素
print("-------读取下标对应的元素-------")
x2 = x[[0, 6]] # 使用花式索引
print(x2)

print(x2[0])
print(x2[1])
1
2
3
4
5
6
7
import numpy as np 

x=np.arange(32).reshape((8,4))
print(x)
# 二维数组读取指定下标对应的行
print("-------读取下标对应的行-------")
print (x[[4,2,1,7]])

广播(Broadcast)

1
2
3
4
5
6
7
8
9
import numpy as np 

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
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np

a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):
    print (x, end=", " )
print ('\n')     
/*
原始数组是：
[[0 1 2]
 [3 4 5]]
迭代输出元素：
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，即是行序优先；

数组操作

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

修改数组形状

numpy.reshape

1
numpy.reshape(arr, newshape, order='C')

numpy.ndarray.flat

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)

#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)

numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下： 

1
ndarray.flatten(order='C')

numpy.ravel

1
numpy.ravel(a, order='C')

翻转数组

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

numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

1
numpy.transpose(arr, axes)

numpy.rollaxis

numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：

1
numpy.rollaxis(arr, axis, start)

numpy.swapaxes

numpy.swapaxes 函数用于交换数组的两个轴，格式如下：

1
numpy.swapaxes(arr, axis1, axis2)

随机ndarray数组

创建随机ndarray数组主要包含设置随机种子、均匀分布和正态分布三部分内容

  • 设置随机数种子
1
2
3
4
# 可以多次运行，观察程序输出结果是否一致
# 如果不设置随机数种子，观察多次运行输出结果是否一致
np.random.seed(10)
a = np.random.rand(3, 3)
  • 均匀分布
1
2
# 生成均匀分布随机数，随机数取值范围在[0, 1)之间
a = np.random.rand(3, 3)

生成均匀分布随机数，指定随机数取值范围和数组形状

a = np.random.uniform(low = -1.0, high = 1.0, size=(2,2))

1
2
3
4
5
6
7
8
9
10
```



- **正态分布**

```python
# 生成标准正态分布随机数
a = np.random.randn(3, 3)
a = np.random.normal(loc = 1.0, scale = 1.0, size = (3,3))