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