Numpy概述
NumPy 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。NumPy 是一个运行速度非常快的数学库，主要用于数组计算，主要功能包括线性代数、傅里叶变换、随机数生成等功能。底层核心是ndarray。
Numpy特点
-
代码更简洁：Numpy直接以数组、矩阵为粒度进行计算，并且支持大量的数学函数；
-
性能更高效：Numpy底层采用C语言实现、释放了GIL锁、算法更先进；
-
是其他数据科学库的基础：Numpy是Pandas、SciPy、Scikit-Learn、Tensorflow等库的基础
Numpy安装
pip install numpy pip install numpy -i https://pypi.douban.com/simple/
若pip安装不成功可以通过wheel方式安装
# whl文件名称是：numpy-1.21.1-cp38-cp38-win_amd64.whl，若安装不成功，将其名称改为numpy-1.21.1-cp38-none-win_amd64.whl pip install numpy-1.21.1-cp38-cp38-win_amd64.whl pip install numpy-1.21.1-cp38-none-win_amd64.whl
获取当前版本
import numpy as np print(np.__version__)
获取帮助信息
import numpy as np print(help(np.info(np.random.rand)))
ndarray对象
NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray特点
-
ndarray 对象是用于存放同类型元素的多维数组
-
ndarray 中的每个元素在内存中都有相同存储大小的区域
ndarray内部结构
-
一个指向数据（内存或内存映射文件中的一块数据）的指针。
-
数据类型或 dtype，描述在数组中的固定大小值的格子。
-
一个表示数组形状（shape）的元组，表示各维度大小的元组。
-
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。
性能对比
import numpy as np import time def sum(n): param1 = [i ** 2 for i in range(n)] param2 = [i ** 3 for i in range(n)] result = [] for i in range(n): result.append(param1[i] + param2[i]) return result time_begin = time.time() sum(1000000) time_end = time.time() print(time_end - time_begin) # 622ms def sum1(n): param1 = np.arange(n) **2 param2 = np.arange(n) **3 return param1 + param2 time_start = time.time() sum1(1000000) time_stop = time.time() print(time_stop - time_start) # 9ms
Numpy基本操作
创建数组
array函数
import numpy as np np.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 参数 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
import numpy as np arr1 = np.array([1, 2, 3]) print(arr1) # 一维数组 arr2 = np.array([[1, 2, 3], [4, 5, 6]]) print(arr2) # 二维数组 arr3 = np.array([[[1, 2], [3, 4]], [[1, 2], [3, 4]]]) print(arr3) # 三维数组 # 通过指定维数(ndim)创建数组 arr4 = np.array([1, 2, 3, 4, 5], ndmin=2) print(arr4) # [[1 2 3 4 5]]
python列表创建数组
import numpy as np num_list = [4, 5, 6, 7] result = np.array(num_list) print(result) # [4 5 6 7] print(type(result)) # <class 'numpy.ndarray'> print(result.size) # 4 print(result.shape) # (4,)
python元组创建数据
import numpy as np num_list = (4, 5, 6, 7) result = np.array(num_list) print(result) # [4 5 6 7] print(type(result)) # <class 'numpy.ndarray'> print(result.size) # 4 print(result.shape) # (4,)
python集合创建数组
import numpy as np
# 采用集合创建numpy数组时，将集合整体作为数组的一个元素
num_list = {4, 5, 6, 7}
result = np.array(num_list)
print(result) # {4, 5, 6, 7}
print(type(result)) # <class 'numpy.ndarray'>
print(result.size) # 1
print(result.shape) # ()
字典创建数组
import numpy as np
# 采用字典创建numpy数组时，将字典整体作为数组的一个元素
dic_list = {
"name": "Mary",
"age": 18
}
result3 = np.array(dic_list)
print(result3) # {'name': 'Mary', 'age': 18}
print(type(result3)) # <class 'numpy.ndarray'>
print(result3.size) # 1
print(result3.shape) # ()
通过集合和字典创建时属性值与预期不同。通常numpy与list结合使用
数据类型dtype
| 名称 | 描述 |
|---|---|
| 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 位浮点数（实数部分和虚数部分） |
默认类型
import numpy as np num_list = np.array([3, 5, 6, 8]) print(num_list.dtype) # int32 num_list1 = np.array([4.5, 2.4, 7.5]) print(num_list1.dtype) # float64 num_list2 = np.array([1 + 3j, 3 + 5j]) print(num_list2.dtype) # complex128
Numpy整形、浮点型、复数默认的值为int32、float64、complex128
指定类型创建数组
import numpy as np arr = np.array([1, 2, 3, 4], dtype=bool) print(arr) # [ True True True True] arr1 = np.array([1, 2, 3, 4], dtype=np.float32) arr1_1 = np.array([1, 2, 3, 4], dtype=float) print(arr1) # [1. 2. 3. 4.] print(arr1_1) # [1. 2. 3. 4.] arr2 = np.array([1, 2, 3, 4], dtype=str) print(arr2) # ['1' '2' '3' '4'] arr3 = np.array([1, 2, 3, 4], dtype=np.complex64) print(arr3) # [1.+0.j 2.+0.j 3.+0.j 4.+0.j] arr4 = np.array([1, 2, 3.5, '4'], dtype=object) print(arr4) # [1 2 3.5 '4']
通过指定类型创建数组时，np.int32与int等价；np.float64与float等价；np.complex128与complex等价。
Ndarray中的数据必须是同一类型，否则会自动向下转换。int -> float -> str
import numpy as np arr1 = np.array([1,2,3,4,'5']) print(arr1) # ['1' '2' '3' '4' '5'] arr2 = np.array([1,2,3,4,5.0]) print(arr2) # [1. 2. 3. 4. 5.]
数组属性
| 属性 | 描述 |
|---|---|
| dtype | 数据类型 |
| ndim | 维度数量或轴的数量 |
| shape | 维度或形状（行，列） |
| size | 元素个数 |
| itemsize | 元素字节数 |
| nbytes | 数组总共字节数 (nbytes = size * itemsize) |
数组属性操作
import numpy as np # 一维数组 arr1 = np.array([4, 5, 6]) print(type(arr1)) # <class 'numpy.ndarray'> print(arr1.dtype) # int32 print(arr1.size) # 3 print(arr1.ndim) # 1 print(arr1.shape) # (3,) print(arr1.itemsize) # 4 (整形占4个字节) print(arr1.nbytes) # 12 # 二维数组 arr2 = np.array([[1, 2, 3], [4, 5, 6]]) print(type(arr2)) # <class 'numpy.ndarray'> print(arr2.dtype) # int32 print(arr2.size) # 6 print(arr2.ndim) # 2 print(arr2.shape) # (2, 3) print(arr2.itemsize) # 4 (整形占4个字节) print(arr2.nbytes) # 24
shape()函数以元组的形式返回数组的形状，若数组是一维的，返回数组元素个数
改变数组维度
import numpy as np arr = np.array([3, 5, 8, 5, 3, 7, 6, 3, 7]) print(arr) # [3 5 8 5 3 7 6 3 7] tar = arr.reshape(3, 3) print(tar) ''' [[3 5 8] [5 3 7] [6 3 7]] ''' # ndarray.reshape 通常返回的是非拷贝副本，即改变返回后数组的元素，原数组对应元素的值也会改变。 tar[1, 1] = 100 print(arr) # [3 5 8 5 100 7 6 3 7] print(tar) ''' [[ 3 5 8] [ 5 100 7] [ 6 3 7]] '''
数组访问
索引访问
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(arr[1, 1]) # 5 print(arr[1][1]) # 5 print(arr[1]) # [4 5 6] 访问数组第二行 print(arr[:,1]) # [2,5,8] 访问数组第二列
切片访问
一维数组
import numpy as np arr = np.array([4, 5, 6, 7, 8, 9]) print(arr[1:3]) # [5 6] print(arr[-2:]) # [8 9] print(arr[:-2]) # [4 5 6 7] print(arr[::]) # [4 5 6 7 8 9] print(arr[::-1]) # [9 8 7 6 5 4] print(arr[0:len(arr):3]) # [4, 7]
切片arr(begin, end, step)，其中范围为[begin, end)
二维数组
import numpy as np arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) print(arr[:1]) # [[1 2 3 4]] print(arr[1, 1:3]) # [6,7] ''' arr[:2] 结果为： [ [1 2 3 4] [5 6 7 8] ] arr[:, :2]结果为： [ [ 1 2] [ 5 6] [ 9 10] ] ''' print(arr[:2]) print(arr[:, :2])
n维数组切片访问返回的是n维数组
高级索引访问
通过布尔类型数组作为索引进行数据过滤
import numpy as np arr = np.array([1, 2, 3, 4]) bool_arr = np.array([0, 1, 1, 0], dtype=bool) print(bool_arr) # [False True True False] result = arr[bool_arr] print(result) # [2 3]
通过过滤条件访问
import numpy as np arr = np.array([1, 2, 3, 4]) mask = arr > 2 print(mask) # [False False True True] print(arr[mask]) # [3 4] arr1 = arr[arr > 2] print(arr1) # [3 4]
通过传递判断条件进行数据过滤，其本质还是传递了一个布尔类型的ndarray数组
通过传递索引值过滤数据
import numpy as np arr1 = np.array([1, 2, 3, 4]) print(np.where(arr1)) # (array([0, 1, 2, 3], dtype=int64),) 返回索引 print(np.where(arr1 > 2)) # (array([2, 3], dtype=int64),) print(arr1[np.where(arr1 > 2)]) # [3 4]
通过传递判断条件进行数据过滤，其本质是传递了一个包含满足条件索引的ndarray数组
赋值访问
采用直接赋值方法，一改全改
import numpy as np arr1 = np.array([1, 2, 3, 4]) arr2 = arr1 arr2[1] = 100 print(arr1) # [1 100 3 4] print(arr2) # [1 100 3 4]
采用copy()赋值彼此独立
arr1 = np.array([1, 2, 3, 4]) arr2 = arr1.copy() arr2[1] = 100 print(arr1) # [1 2 3 4] print(arr2) # [1 100 3 4]
遍历数组
通过nditer()进行遍历
import numpy as np # 获取所有数据 arr = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]]) for val in np.nditer(arr): print(val, end=",") # 9,8,7,6,5,4,3,2,1, # 获取部分数据 arr = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]]) for val in np.nditer(arr[1]): print(val, end=",") # 6,5,4,
通过ndenumerate()进行遍历
import numpy as np arr = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]]) for index,value in np.ndenumerate(arr): print(index,value) ''' (0, 0) 9 (0, 1) 8 (0, 2) 7 (1, 0) 6 (1, 1) 5 (1, 2) 4 (2, 0) 3 (2, 1) 2 (2, 2) 1 '''
设置矩阵不可修改
import numpy as np # numpy数组值默认可修改 arr = np.array([1, 9, 3, 4]) arr1 = arr arr[1] = 30 print(arr) # [1 30 3 4] print(arr1) # [1 30 3 4] # 通过writeable属性可设置数组值不可变 arr1 = np.array([1, 2, 3, 4, 5]) arr1.flags.writeable = False arr1[0] = 1 # 报错
数组生成函数
asarray()
import numpy as np arr = np.array([1, 2, 3, 4]) tar = np.asarray(arr, dtype=np.float32) print(arr) # [1 2 3 4] (不改变原始值) print(tar) # [1. 2. 3. 4.]
astype创建
import numpy as np arr = np.array([1, 2, 3, 4]) tar = arr.astype(np.float32) print(arr) # [1 2 3 4] (不改变原始值) print(tar) # [1. 2. 3. 4.]
fill创建
import numpy as np alist = np.array([4, 5, 6, 7]) alist.fill(7) print(alist) # [7 7 7 7]
| 函数 | 描述 |
|---|---|
| arange(start, stop, step, dtype) | 根据范围和步长创建等差数组 |
| linspace(start, stop, num, endpoint, retstep, dtype) | 根据范围和个数创建等差数组 |
| logspace(start, stop, num, endpoint, base, dtype) | 根据范围和个数创建等比数组 |
arange(start, stop, step, dtype)
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
import numpy as np print(np.arange(10)) # [0 1 2 3 4 5 6 7 8 9] print(np.arange(2, 10, 2)) # [2 4 6 8] print(np.arange(2, 20, 2, dtype=float)) # [ 2. 4. 6. 8. 10. 12. 14. 16. 18.]
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的数据类型 |
import numpy as np print(np.linspace(2, 3, num=5)) # [2. 2.25 2.5 2.75 3. ] print(np.linspace(2, 3, num=5, endpoint=False)) # [2. 2.2 2.4 2.6 2.8] print(np.linspace(2, 3, num=5, retstep=True)) # (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) print(np.linspace(1, 1, 10)) # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] print(np.linspace(1, 1, 10, retstep=True)) # (array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]), 0.0)
arange()和linspace()区别在于：前者是根据范围和步长生成等差数组；后者是通过范围和个数生成等差数组
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 的底数，即取对数的时候 log 的下标 |
| dtype | ndarray的数据类型 |
import numpy as np print(np.logspace(0, 3, 4)) # [ 1. 10. 100. 1000.] print(np.logspace(0, 5, 6, base=2)) # [ 1. 2. 4. 8. 16. 32.]
| 函数 | 描述 |
|---|---|
| empty(shape, dtype = float, order = 'C') | 创建一个指定形状、数据类型且未初始化的数组 |
| zeros(shape, dtype = float, order = 'C') | 创建指定大小的数组，数组元素以 0 来填充 |
| ones(shape, dtype = None, order = 'C') | 创建指定形状的数组，数组元素以 1 来填充 |
| identity(n, dtype=None, *, like=None) | 创建对角矩阵，只能是方阵 |
| eye(N, M, k, dtype, order, *, like) | 创建对角矩阵，可以为非方阵 |
函数参数含义
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
empty()
import numpy as np print(np.empty(3)) # 一维未初始化数组 print(np.empty((3, 3))) # 二维未初始化数组 print(np.empty((3, 3), dtype=np.int16)) # 指定类型的二维空数组 ''' 运行结果为： [0. 0.5 1. ] [[6.23042070e-307 4.67296746e-307 1.69121096e-306] [1.86921822e-306 1.29057407e-306 1.24611741e-306] [1.11261027e-306 2.07955588e-312 7.27378088e+175]] [[ 0 0 0] [ 0 5200 -29400] [ 32761 0 5200]] '''
empty() 返回一个一维或者多维数组，数组的元素不为空，为随机产生的数据。
zeros()
import numpy as np print(np.zeros(5)) print(np.zeros((4, 4))) print(np.zeros((4, 4), dtype=np.int32)) ''' 返回结果为： [0. 0. 0. 0. 0.] [[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]] [[0 0 0 0] [0 0 0 0] [0 0 0 0] [0 0 0 0]] '''
ones()
import numpy as np print(np.ones(5)) print(np.ones((4, 4))) print(np.ones((4, 4), dtype=np.int32)) ''' 返回结果为： [1. 1. 1. 1. 1.] [[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]] [[1 1 1 1] [1 1 1 1] [1 1 1 1] [1 1 1 1]] '''
identity()
import numpy as np # 默认类型为浮点型 arr = np.identity(3) print(arr) # 指定类型创建 arr1 = np.identity(3, dtype=np.int32) print(arr1)
identity只能创建方阵
eye(N, M=None, k=0, dtype=float, order='C', *, like=None)
| 参数 | 描述 |
|---|---|
| N,M | 指定矩阵的shape，若M省略，则创建方阵，功能同identity() |
| k | 对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角 |
| dtype | 数据类型，默认float |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
import numpy as np print(np.eye(3)) ''' [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] ''' arr = np.eye(3,4,k=1) print(arr) arr2 = np.eye(3,4,k=2) print(arr2) arr3 = np.eye(3,4,k=-1) print(arr3) arr4 = np.eye(3,4,k=-2) print(arr4) ''' k=1 k=2 k=-1 k=-2 [[0. 1. 0. 0.] [[0. 0. 1. 0.] [[0. 0. 0. 0.] [[0. 0. 0. 0.] [0. 0. 1. 0.] [0. 0. 0. 1.] [1. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 1.]] [0. 0. 0. 0.]] [0. 1. 0. 0.]] [1. 0. 0. 0.]] '''
zeros_like() / ones_like()
# 根据已有 import numpy as np arr = np.array([3, 4, 5, 6]) print(np.zeros_like(arr)) # [0 0 0 0] print(np.ones_like(arr)) # [1 1 1 1] arr1 = np.array([[1, 2, 3], [4, 5, 6]]) print(np.zeros_like(arr1)) print(np.ones_like(arr1))
数值计算
四则运算
| 函数 | 描述 |
|---|---|
| add() | + | 加法 |
| subtract() | - | 减法 |
| multiply() | * | 乘法 |
| divide() | / | 除法 |
Numpy支持数组之间的四则运算。
import numpy as np arr1 = np.array([10, 20, 30]) arr2 = np.array([1, 2, 3]) # 加法 print(np.add(arr1, arr2)) # [11 22 33] print(arr1 + arr2) # [11 22 33] # 减法 print(np.subtract(arr1, arr2)) # [9 18 27] print(arr1 - arr2) # [9 18 27] # 乘法 print(np.multiply(arr1, arr2)) # [10 40 90] print(arr1 * arr2) # [10 40 90] # 除法 print(np.divide(arr1, arr2)) # [10. 10. 10.] print(arr1 / arr2) # [10. 10. 10.]
推荐使用四则运算符实现size运算，书写简单。
比较运算
import numpy as np arr1 = np.array([1, 20, 3]) arr2 = np.array([1, 2, 3]) print(arr1 == arr2) # [True False True]
逻辑运算
import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([5, 0, 4]) print(np.logical_and(arr1, arr2)) # [ True False True] print(np.logical_or(arr1, arr2)) # [ True True True] print(np.logical_not(arr1)) # [False False False] print(np.logical_not(arr2)) # [False True False] print(np.logical_xor(arr1, arr2)) # [False True False]
Numpy函数
轴
数学函数
| 函数 | 描述 |
|---|---|
| sin() | 正弦（参数单位为弧度） |
| cos() | 余弦（参数单位为弧度） |
| tan() | 正切（参数单位为弧度） |
| arcsin() | 反正弦（返回值单位为弧度） |
| arccos() | 反余弦（返回值单位为弧度） |
| arctan() | 反正弦（返回值单位为弧度） |
| degrees() | 将弧度转换为角度 |
sin()/arcsin()
import numpy as np
arr = np.array([0, 30, 45, 60, 90])
print('含有正弦值的数组：')
sin = np.sin(arr * np.pi / 180)
print(sin) # [0. 0.5 0.70710678 0.8660254 1.]
print('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)
print(inv) # [0. 0.52359878 0.78539816 1.04719755 1.57079633]
print('通过转化为角度制来检查结果：')
print(np.degrees(inv)) # [0. 30. 45. 60. 90.]
cos()/arccos()
import numpy as np
arr = np.array([0, 30, 45, 60, 90])
print('arccos：')
cos = np.cos(arr * np.pi / 180)
print(cos) # [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17]
print('反余弦：')
inv = np.arccos(cos)
print(inv) # [0. 0.52359878 0.78539816 1.04719755 1.57079633]
print('角度制单位：')
print(np.degrees(inv)) # [0, 30, 45, 60, 90]
tan()/arctan()
import numpy as np
arr = np.array([0, 30, 45, 60, 90])
print('tan 函数：')
tan = np.tan(arr * np.pi / 180)
print(tan) # [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 1.63312394e+16]
print('反正切：')
inv = np.arctan(tan)
print(inv) # [0. 0.52359878 0.78539816 1.04719755 1.57079633]
print('角度制单位：')
print(np.degrees(inv)) # [0, 30, 45, 60, 90]
| 函数 | 描述 |
|---|---|
| around(arr,decimals) | 四舍五入（decimals为小数位数） |
| floor() | 向下取整 |
| ceil() | 向上取整 |
around(arr,decimals)
import numpy as np
arr = np.array([1.0, 5.55, 123, 0.567, 25.532])
print('原数组：')
print(arr) # [1. 5.55 123. 0.567 25.532]
print('舍入后：')
print(np.around(arr)) # [1. 6. 123. 1. 26.]
print(np.around(arr, decimals=1)) # [1. 5.6 123. 0.6 25.5]
print(np.around(arr, decimals=-1)) # [0. 10. 120. 0. 30.]
如果decimals为负，整数将四舍五入到小数点左侧的位置
floor()
import numpy as np arr = np.array([-1.7, 1.5, -0.2, 0.6, 10]) print(arr) # [-1.7 1.5 -0.2 0.6 10.] print(np.floor(arr)) # [-2. 1. -1. 0. 10.]
ceil()
import numpy as np arr = np.array([-1.7, 1.5, -0.2, 0.6, 10]) print(arr) # [-1.7 1.5 -0.2 0.6 10.] print(np.ceil(arr)) # [-1. 2. -0. 1. 10.]
算数函数
| 函数 | 描述 |
|---|---|
| reciprocal() | 返回元素倒数 |
| power() | 幂指数 |
| mod() | 余数 |
reciprocal()
import numpy as np arr = np.array([10, 20, 30]) print(arr) # [10 20 30] print(np.reciprocal(arr)) # [0 0 0] arr2 = np.array([10, 20, 30], dtype=np.float32) print(arr2) # [10. 20. 30.] print(np.reciprocal(arr2)) # [0.1 0.05 0.03333334]
采用reciprocal()求取倒数时，元素必须是浮点型的
pow()
import numpy as np # pow()将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂 arr = np.array([10, 100, 1000]) print(arr) # [10 100 1000] print(np.power(arr, 2)) # [100 10000 1000000] print(arr ** 2) # [100 10000 1000000] (推荐) pows = np.array([1, 2, 3]) print(pows) # [1 2 3] print(np.power(arr, pows)) # [10 10000 1000000000]
mod()
arr = np.array([10, 20, 30]) param = np.array([3, 5, 7]) print(arr) # [10 20 30] print(param) # [3 5 7] print(np.mod(arr, param)) # [1 0 2] print(arr % param) # [1 0 2] (推荐)
统计函数
| 函数 | 描述 |
|---|---|
| sum | 求和（返回一维ndarray数组） |
| prod | 求积（返回一维ndarray数组） |
| cumsum | 求累计和（返回值与原数组维度相同） |
| cumprod | 求累计乘积（返回值与原数组维度相同） |
| min() | 计算数组中的元素沿指定轴的最小值（返回一维ndarray数组） |
| max() | 计算数组中的元素沿指定轴的最大值（返回一维ndarray数组） |
| argmin() | 返回最小值索引（返回一维ndarray数组） |
| argmax() | 返回最大值索引（返回一维ndarray数组） |
sum()
import numpy as np # 求数组所有元素的和 num_list = np.array([[1, 2, 3], [4, 5, 6]]) print(num_list.sum()) # 21 print(np.sum(num_list)) # 21 # 按轴进行求和 print(num_list.sum(0)) # [5 7 9] print(np.sum(num_list, 0)) # [5 7 9] print(num_list.sum(1)) # [6 15] print(np.sum(num_list, axis=1)) # [6 15] print(np.sum(num_list, axis=-1)) # [6 15] 按最后一个轴进行累加
prod()
import numpy as np # 求数组所有元素的积 num_list = np.array([[1, 2, 3], [4, 5, 6]]) print(num_list.prod()) # 720 print(np.prod(num_list)) # 720 # 按轴进行求积 print(num_list.prod(0)) # [4 10 18] print(np.prod(num_list, 0)) # [4 10 18] print(num_list.prod(1)) # [6 120] print(np.prod(num_list, axis=1)) # [6 120] print(np.prod(num_list, axis=-1)) # [6 120] 按最后一个轴进行累乘
cumsum()
import numpy as np # 计算累积和 arr = np.array([[1, 2, 3], [4, 5, 6]]) ''' [[1 2 3] [4 5 6]] ''' print(arr) print(np.cumsum(arr)) # [1 3 6 10 15 21] print(np.cumsum(arr, dtype=float)) # [1. 3. 6. 10. 15. 21.] ''' [[1 2 3] [5 7 9]] ''' print(arr.cumsum(axis=0)) ''' [[ 1 3 6] [ 4 9 15]] ''' print(arr.cumsum(axis=1))
cumprod()
import numpy as np # 计算累积乘积 arr = np.array([[1, 2, 3], [4, 5, 6]]) ''' [[1 2 3] [4 5 6]] ''' print(arr) print(np.cumprod(arr)) # [1 2 6 24 120 720] print(np.cumprod(arr, dtype=float)) # [1. 2. 6. 24. 120. 720.] ''' [[ 1 2 3] [ 4 10 18]] ''' print(arr.cumprod(axis=0)) ''' [[ 1 2 6] [ 4 20 120]] ''' print(arr.cumprod(axis=1))
min()
import numpy as np # 求数组所有元素最小值 arr = np.array([[1, 2, 3], [4, 5, 6]]) print(np.min(arr)) # 1 # 按轴计算最小值 print(np.min(arr, axis=0)) # [1 2 3] print(arr.min(axis=1)) # [1 4]
max()
import numpy as np # 求数组所有元素最大值 arr = np.array([[1, 2, 3], [4, 5, 6]]) print(np.max(arr)) # 6 # 按轴计算最大值 print(np.max(arr, axis=0)) # [4 5 6] print(arr.max(axis=1)) # [3 6]
argmin()
import numpy as np # 求数组所有元素最小值的索引 arr = np.array([[9, 1, 30], [4, 5, 6]]) print(arr.argmin()) # 1 # 按轴计算数组元素最小值的索引 print(arr.argmin(axis=0)) # [1 0 1] print(arr.argmin(axis=1)) # [1,0]
argmax()
import numpy as np # 求数组所有元素最大值的索引 arr = np.array([[9, 1, 30], [4, 5, 6]]) print(arr.argmax()) # 2 # 按轴计算数组元素最大值的索引 print(arr.argmax(axis=0)) # [0 1 0] print(arr.argmax(axis=1)) # [2 2]
| 函数 | 描述 |
|---|---|
| ptp() | 计算数组中元素最大值与最小值之差 |
| median() | 计算数组中位数 |
| mean() | 计算数组算数平均数 |
| average() | 计算数组元素加权平均值 |
| var() | 计算数组元素方差 |
| std() | 计算数组元素标准差 |
ptp()
import numpy as np # 计算数组中元素最大值与最小值之差 arr = np.array([[3, 7, 5], [-8, 4, 3], [2, 4, 9]]) ''' [[ 3 7 5] [-8 4 3] [ 2 4 9]] ''' print(arr) print(np.ptp(arr)) # 17 # 按轴计算数组中元素最大值与最小值之差 print(np.ptp(arr, axis=1)) # [4 12 7] print(np.ptp(arr, axis=0)) # [11 3 6] print(arr.ptp(axis=-1)) # [4 12 7] 按最后一个轴求取元素最大值与最小值之差
median()
import numpy as np # 计算数组中所有元素的中位数 arr = np.array([[3, 7, 5], [-8, 4, 3], [2, 4, 9]]) ''' [[ 3 7 5] [-8 4 3] [ 2 4 9]] ''' print(arr) print(np.median(arr)) # 4 # 按轴计算数组中元素的中位数 print(np.median(arr, axis=1)) # [5. 3. 4.] print(np.median(arr, axis=0)) # [2. 4. 5.] print(np.median(arr, axis=-1)) # [5. 3. 4.]
平均值
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) print(np.mean(arr)) # 3.5 print(np.mean(arr, axis=0)) # [2.5 3.5 4.5] print(np.mean(arr, axis=1)) # [2. 5.]
标准差
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) print(np.std(arr)) # 1.707825127659933 print(np.std(arr, axis=0)) # [1.5 1.5 1.5] print(np.std(arr, axis=1)) # [0.81649658 0.81649658]
方差
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) print(np.var(arr)) # 2.9166666666666665 print(np.var(arr, axis=0)) # [2.25 2.25 2.25] print(np.var(arr, axis=1)) # [0.66666667 0.66666667]
数值限制
import numpy as np num_list = np.array([1,2,3,4,5,6,7,8]) # 小于3的赋值为3，大于6赋值为6 print(num_list.clip(3,6)) # [3 3 3 4 5 6 6 6]
非0索引
import numpy as np arr = np.array([1, 0, 2, 3, 4, 0, 3, 0]) print(np.nonzero(arr)) # (array([0, 2, 3, 4, 6], dtype=int64),) print(arr.nonzero()) # (array([0, 2, 3, 4, 6], dtype=int64),)
排序操作
import numpy as np arr = np.array([[1.5, 1.3, 7.5], [5.6, 7.8, 1.2]]) print(arr) print(np.sort(arr)) print(np.sort(arr, axis=0)) ''' [[1.5 1.3 7.5] [5.6 7.8 1.2]] [[1.3 1.5 7.5] [1.2 5.6 7.8]] [[1.5 1.3 1.2] [5.6 7.8 7.5]] '''
排序默认是按最后一个轴进行排序
随机模块
| 函数 | 描述 |
|---|---|
| rand() | 生成[0, 1)之间的随机小数 |
| randn() | 生成(-∞,+∞)之间的随机小数 |
| random_sample() | 生成[0, 1)之间的随机小数 |
| randint(low, high, size,dtype) | 生成[low,high)之间的随机整数 |
| normal(loc, scale, size) | 生成(-∞,+∞)之间均值为loc，标准差为scale的正态分布 |
随机浮点数
''' rand(d0, d1, ..., dn)：生成[0, 1)之间的随机小数，数值来源于均匀分布抽样 random(size=None)：生成[0, 1)之间的随机小数，数值来源于均匀分布抽样 randn(d0, d1, ..., dn)生成(-∞,+∞)之间的随机小数，数值来源于标准正态分布抽样 随机小数注意事项： 1. ranf、random、sample、random_sample调用的都是random_sample方法； 2. rand和random_sample效果等价，只是输入参数不同； 3. rand()和randn()都是生成随机小数，区别在于：生成数值的区间不同、分布不同。 ''' import numpy as np print(np.random.rand()) # 返回[0, 1)之间的随机小数 print(np.random.random_sample()) # 返回[0, 1)之间的随机小数 print(np.random.randn()) # 返回(-∞,+∞)之间的随机小数 print(np.random.rand(3,2)) # 返回一个三行两列的矩阵，数值范围[0, 1) print(np.random.random_sample(size=(3，2))) # 返回一个三行两列的矩阵，数值范围[0, 1) print(np.random.randn(3,2)) # 返回一个三行两列的矩阵，数值范围(-∞,+∞)
rand()和randn()都是生成随机小数，区别在于：区间不同、分布不同
随机整数
# randint(low, high=None, size=None, dtype=None) import numpy as np print(np.random.randint(1, 10)) # 产生一个[1,10)之间的随机整数 print(np.random.randint(10)) # 产生一个[0,10)之间的整数(省略high，生成[0,low)之间的随机整数） print(np.random.randint(1, 10, 3)) # 生成三个[1,10)范围内的随机整数 print(np.random.randint(1, 10, size=(3, 3))) # 产生一个3*3矩阵，矩阵数值是[1,10)之间的随机整数 print(np.random.randint(1, high=[3, 5, 10])) # 产生三个上限不同的随机整数 print(np.random.randint([1, 5, 7], 10)) # 产生三个下限不同的随机整数
正态分布
# normal(loc=0.0, scale=1.0, size=None) （均值,标准差,矩阵形状） import numpy as np ''' [[ 0.16360434 1.97129715 -0.72202865 5.54525616] [ 5.30084075 1.16655326 -0.09644836 3.38361816]] ''' print(np.random.normal(3, 2.5, size=(2, 4))) ''' [[ 0.08705979 1.34058832 0.49562195 0.65479645] [-1.41341949 0.90500061 0.14599449 -2.47971539]] ''' print(np.random.normal(size=(2, 4))) ''' [[ 0.222 -0.703 -0.024 1.498] [-0.413 0.283 0.463 -1.421]] ''' np.set_printoptions(precision=3) # 设置打印精度 print(np.random.normal(size=(2, 4)))
洗牌
import numpy as np arr = np.arange(10) print(arr) # [0 1 2 3 4 5 6 7 8 9] np.random.shuffle(arr) print(arr) # [1 0 6 3 2 4 8 9 7 5]
随机种子
# 当指定随机种子后再生成随机数时，每次生成的值都是相同的，不会改变。便于多参数调参时，固定部分参数 import numpy as np np.random.seed(10) arr = np.random.randint(1,10,3) print(arr) # [5 1 2]
高斯分布
import numpy as np np.set_printoptions(precision=3) # 设置打印精度 mu, sigma = 0, 0.1 print(np.random.normal(mu, sigma, 10))
文件操作
文件读取
numpy通过loadtxt()读取文本文件
loadtxt(fname, dtype=float, delimiter=None, skiprows=0, usecols=None, max_rows=None)
import numpy as np
# 文件中数据默认空格分隔
arr = np.loadtxt("first.txt")
# 当不是以空格分隔时，需要指定分隔符号
arr2 = np.loadtxt("second.txt",delimiter=",")
# 当存在表头时，可通过skiprows跳过表头行，序号从1开始
arr3 = np.loadtxt("second.txt",delimiter=",",skiprows=1)
# 通过usecols属性可以指定采用哪几列数据构造数组
arr4 = np.loadtxt("second.txt", delimiter=",", skiprows=1, usecols=(1,3))
文件写入
写入txt文件
def savetxt(fname, arr, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None):
# 默认分隔符为空格
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
np.savetxt("ff.txt", arr, fmt="%.3f", delimiter=",",header='数学 语文 英语', encoding="utf-8")
读写变量
读/写单一变量
# 单一变量/数组通常保存为npy格式文件
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
np.save("arr.npy", arr) # 存储数组
data = np.load("arr.npy") # 读取数组
print(data) # [[1 2 3] [4 5 6]]
读/写多个变量
# 多个变量/数组通常保存为npz格式文件，其本质是一个压缩格式文件，内容有多个文件与保存的变量相对应
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.array([3, 4, 5, 6, 7, 8])
np.savez("arr.npz", arr=arr, arr1=arr1) # 存储数组
data = np.load("arr.npz") # 读取数组
print(data['arr']) # [[1 2 3] [4 5 6]]
print(data['arr1']) # [3 4 5 6 7 8]
练习
1、 生成3*3 的二维数组，数组中数范围位[5.0,10.0)
2、
国内
大数据竞赛平台：DataFountain - 数据科学竞赛创新平台
阿里天池 ： 天池大数据众智平台-阿里云天池
华为云大赛：Huawei Cloud Competitions
百度飞桨：飞桨AI Studio星河社区-人工智能学习与实训社区
智源数据开放研究中心：http://competition.baai.ac.cn/home/competition/ongoing
biendata：Data Competition Community - Biendata
MathorCup高校数学建模挑战赛：MathorCup高校数学建模挑战赛
DC竞赛-大数据竞赛平台：DC竞赛——领先的大数据与人工智能竞赛平台
国外
Kaggle: Your Machine Learning and Data Science Community
https://www.crowdanalytix.com/community
https://datahack.analyticsvidhya.com/?utm_source=main-logo
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
