python---numpy上

原创

wx6323e46448f2a 2025-01-02 16:44:41 博主文章分类：python随笔 ©著作权

文章标签 numpy 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者wx6323e46448f2a的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、numpy简介

Numpy是python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组元素提供大量的数学函数库

1.作用

Numpy是一个运算速度非常快的数学库，主要用于数组计算

2.包含

一个强大的N维数组对象ndarray
广播功能函数
整合c/c++/Fortran代码的工具
线性代数，傅里叶变换，随机数生成等功能

3.优势

对于同样的数值计算任务，使用numpy要比直接编写python代码便携的多
numpy中的数组的存储效率和输入输出性能均远远优于python中等价的基本数据结构，且其能够提升性能是与数组中的元素成比例的
numpy的大部分代码都是用c语言写的，其底层算法在设计时就有优异的性能，这使得numpy比纯python代码高效的多

4.应用

numpy通常与scipy和matplotlib一起使用，这种组合广泛用于替代matlab，是一个强大的科学计算环境，有助于我们用过python学习数据科学或者机器学习。

5.scipy

scipy是一个开源的python算法库和数学工具包，包含的模块有最优化，线性代数，积分，插值，特殊函数，楷书傅里叶变换，信号处理和图像处理，常微分方程求解和其他科学与工程中常用的计算

6.matplotlib

matpoltlib是python编程语言及其数值数学拓展包Numpy的可视化操作界面，它为利用通用的图形用户界面工具包，如Tkinter，wxpython，qt或者gtk+向应用程序嵌入式绘图提供了应用程序接口（API）

7.安装

可使用pip install numpy 或者 conda install numpy

二、Ndarray对象简介

1.介绍

numpy最重要的一个特点是其N维数组对象ndarray，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引
ndarray对象是用于存放同类型元素的多维数组
ndarray中的每个元素在内存中都有相同存储大小的区域

2.组成

python---numpy上_numpy

一个指向数据（内存或内存映射文件中的一块数据）的指针
数据类型或dtype，描述在数组中的固定大小值的格子
一个表示数组形状（shape）的元组，表示各维度大小的元组
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要“跨过”的字节数（空间大小）

三、数组的基本使用

1.numpy数据类型

numpy支持的数据类型比python内置的类型要多很多，基本上可以和c语言的数据类型对应上，其中部分类型对应为python内置的类型
numpy的数值类型实际上是dtype对象的实例，并对应唯一的字符，包括np.bool_,np.int32,np.float32等等

bool_	布尔型数据类型（True或者False）
int_	默认的整数类型（类似于C语言中的long,int32或者int64）
intc	与C的int类型一样，一般是int32或者int64
intp	用于索引的整数类型（类似于C的ssize_t,一般情况下仍然是int32或int64）
int8	字节（-128to127）
int16	整数（-32768to32767）
int32	整数（-2147483648to2147483647）
int64	整数（-9223372036854775808to9223372036854775807）
uint8	无符号整数（0to255）
uint16	无符号整数（0to65535）
uint32	无符号整数（0to4294967295）
uint64	无符号整数（0to18446744073709551615）
float_	float64类型的简写
float16	半精度浮点数，包括：1个符号位，5个指数位，10个尾数位
float32	单精度浮点数，包括：1个符号位，8个指数位，23个尾数位
float64	双精度浮点数，包括：1个符号位，11个指数位，52个尾数位
complex_	complex128类型的缩写，即128位复数
complex64	复数，表示双32位浮点数（实数部分和虚数部分）
complex128	复数，表示双64位浮点数（实数部分的虚数部分）

每个内建类型都有一个唯一定义它的字符代码

b	布尔型
i	（有符号）整型
u	无符号整型integer
f	浮点型
c	复数浮点型
m	timedelta（时间间隔）
M	datetime(日期时间)
o	（python）对象
S,a	（byte）字符串
U	Unicode
V	原始数据（void）

数据类型对象（dtype）

数据类型对象是用来描述与数组对应的内存区域如何使用，这依赖如下几个方面：

数据的类型（整数，浮点数或者python对象）
数据的大小（例如，整数使用多少个字节存储）
数据的字节顺序（小端和大端法）【通过对数据类型预先设定“<”或“>”来决定的。“<”意味着小端法（最小值存储在最小的地址，即低位组放在最前面）。“>”意味着大端法（最重要的字节存储在最小的地址，即高位组放在最前面）】
在结构化类型的情况下，字段的名称，每个字段的数据类型和每个字段所取内存块的部分
如果数据类型是子数组，它的形状和数据类型

创建数据类型对象

原型：numpy.dtype(object, align, copy)

object	要转换的数据类型对象
align	如果为True，填充字段使其类似C的结构体
copy	复制dtype对象，如果为False,则是对内置数据类型对象的引用

基本使用

import numpy as np
dt = np.dtype(np.int32)
print(dt)
print(type(dt))
# 输出结果
# int32
# <class 'numpy.dtype'>

import numpy as np
#int8,int16,int32,int64四种数据类型可以使用字符串'i1','i2','i4','i8'代替
dt = np.dtype('i4')
print(dt)
print(type(dt))
# 输出结果
# int32
# <class 'numpy.dtype'>

2.创建Ndarray数组对象

说明

numpy默认Ndarray的所有元素类型是相同的，这一点与python中的list不同，如果传进来的列表中包含不同的类型，则统一为同一类型，优先级为：str>float>int。

array()函数

原型：numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
作用：创建Ndarray()数组对象

object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

一维数组

import numpy as np
arr = np.array([1,2,3,4,5])
print(arr)
print(type(arr))
# 输出
# [1 2 3 4 5]
# <class 'numpy.ndarray'>

元素类型要相同

import numpy as np
arr = np.array([1,2,3.5,4])
print(arr)
print(type(arr))
# 输出
#[1.  2.  3.5 4. ]
#<class 'numpy.ndarray'>

多维数组

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(type(arr))
# 输入
# [[1 2 3]
# [4 5 6]]
# <class 'numpy.ndarray'>

规定最小维度

import numpy as np
arr = np.array([1,2,3,4,5], ndmin=2)
print(arr)
print(type(arr))
# 输出
# [[1 2 3 4 5]]
# <class 'numpy.ndarray'>

dtype参数

import numpy as np
student = np.dtype([("name", "S20"),("age", "i1"),("marks", "f4")])
arr = np.array([("zs", 20, 100), ("ls", 18, 100)], student)
print(arr)
print(type(arr))
# 输出
# [(b'zs', 20, 100.) (b'ls', 18, 100.)]
# <class 'numpy.ndarray'>

asarray()函数

原型：numpy.asarray(a, dtype = None, order = None)
作用：类似numpy.array, 但numpy.asarray只有三个参数，比numpy.array少两个

a	任意形式的输入参数，可以是列表，列表的元组，元组，元组的元组，元组的列表，多维数组
dtype	数据类型，可选
order	可选，有“C”和“F”两个选项，分别代表，行优先和列优先，在计算机内存中的存储元素的顺序

import numpy as np
arr = np.asarray([1,2,3,4,5])
print(arr)
print(type(arr))
# 输出
# [1 2 3 4 5]
# <class 'numpy.ndarray'>

arr = np.asarray((1,2,3,4,5))
print(arr)
# 输出
# [1 2 3 4 5]

arr = np.asarray([(1,2,3),(4,5,6)])
print(arr)
# 输出
# [[1 2 3]
# [4 5 6]]

arr = np.asarray([1,2,3,4,5], dtype = "f")
print(arr)
#[1. 2. 3. 4. 5.]

empty()函数

原型：numpy.empty(shape, dtype = float, order = "C")
作用：创建一个指定形状（shape),数据类型（dtype）且未初始化的数组

shape	数组形状
dtype	数剧类型，可选
order	有”C“和”F“两种选项，分别代表，行优先和列优先，在计算机内存中的存储元素的顺序

import numpy as np
arr = np.empty([3,2], dtype="i")
print(arr)
# 输出
# 初始化，数值的值每次运行都会变化
#[[1877552304        444]
#[         0          0]
#[         1          0]]

zeros()函数

原型：numpy.zeros(shape, dtype=float, order="C")
作用：创建指定大小的数组，数组元素以0来填充

shape	数组的形状
dtype	数剧的类型，可选
order	“C”用于行数组，或者“F”用于列数组

import numpy as np
arr = np.zeros(5)
print(arr)
#输出
#[0. 0. 0. 0. 0.]

arr = np.zeros([3,2])
print(arr)
#输出
#[[0. 0.]
# [0. 0.]
# [0. 0.]]

arr = np.zeros([3,2], dtype="i")
print(arr)
#输出
#[[0 0]
# [0 0]
# [0 0]]

arr = np.zeros([3,2], dtype=[("x", "i"), ("y", "f")])
print(arr)
#输出
#[[(0, 0.) (0, 0.)]
# [(0, 0.) (0, 0.)]
# [(0, 0.) (0, 0.)]]

ones()函数

原型：numpy.ones(shape, dtype=None, order="C")
作用：创建指定形状的数组，数组元素以1来填充

shape	数组形状
dtype	数剧类型，可选
order	C用于C的行数组，或者F用于FORTRAN的列数组

import numpy as np
arr = np.ones(5)
print(arr)
#输出
#[1. 1. 1. 1. 1.]

arr = np.ones([3,2])
print(arr)
#输出
#[[1. 1.]
# [1. 1.]
# [1. 1.]]

arr = np.ones([3,2], dtype="i")
print(arr)
#输出
#[[1 1]
# [1 1]
# [1 1]]

arr = np.ones([3,2], dtype=[("x","i"),("y","f")])
print(arr)
#输出
#[[(1, 1.) (1, 1.)]
# [(1, 1.) (1, 1.)]
# [(1, 1.) (1, 1.)]]

full()函数

原型：numpy.full(shape, fill_value, dtype=None, order="C")
作用：创建指定形状的数组，数组元素以fill_value来填充

shape	数组形状
fill_value	填充的数据
dtype	数剧类型，可选
order	C用于C的行数组，或者F用于FORTRAN的列数组

import numpy as np
arr = np.full([3,2],fill_value=1024,dtype="i4")
print(arr)
#输出
#[[1024 1024]
# [1024 1024]
# [1024 1024]]

eye()函数

原型：numpy.eye(N,M=None,k=0, dtype=float, order="C")
作用：对角线为1其他位置为0

N	行数量
M	列数量
dtype	数剧类型，可选
order	C用于C的行数组，或者F用于FORTRAN的列数组

import numpy as np
arr = np.eye(3,dtype="i4")
print(arr)
# 输出
# [[1 0 0]
# [0 1 0]
# [0 0 1]]

arange()函数

原型：numpy.arange(start, stop, step, dtype)
作用：创建数值范围并返回ndarray对象，根据start与stop指定的范围以及step设定的步长，生成一个ndarray

start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型

import numpy as np
arr = np.arange(1, 11, 2, dtype="i4")
print(arr)
# 输入
# [1 3 5 7 9]

frombuffer()函数

原型：numpy.frombuffer(buffer, dtype=float, count=-1,offset=0)
作用：用于实现动态数组，接收buffer输入参数，以流的形式读入转化成ndarray对象
注意：buffer是字符串的时候，python3默认str是unicode类型，所以要转成bytestring再原str前面加上b

buffer	可以是任意对象，会以流的形式读入
dtype	返回数组的数据类型，可选
count	读取的数据数量，默认为-1，读取所有数据
offset	读取的起始位置，默认为0

import numpy as np
str_ = b"hello world"
arr = np.frombuffer(str_, dtype="S1", count=5, offset=2)
print(arr)
# 输出
# [b'l' b'l' b'o' b' ' b'w']

fromiter()函数

原型：numpy.fromiter(iterable, dtype, count=-1)
作用：从可迭代的对象中建立ndarray对象，返回一维数组

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

import numpy as np
x = [1,2,3,4,5]
z = iter(x)
print(z)
arr = np.fromiter(z, dtype="i4", count=4) 
print(arr)
# 输出
# <list_iterator object at 0x000002D77FEC9080>
# [1 2 3 4]

linspace()函数

原型：numpy.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
arr = np.linspace(1,10,3,dtype="i4")
print(arr)
# 输出
# [ 1  5 10]

logspace()函数

原型：numpy.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的底数，默认是10
dtype	ndarray的数据类型

import numpy as np
arr = np.logspace(1,10,10,dtype="i4",base=2)
print(arr)
# 输出
# [   2    4    8   16   32   64  128  256  512 1024]

random.rand()

原型：numpy.random.rand(d0,d1,d2,.....,dn)
作用：生成[0,1)之间的随机数

生成0,1之间的随机数

import numpy as np
arr = np.random.rand()
print(arr)
# 0.9185363156761576

生成一个有3个元素的一维数组，元素值在0到1之间

import numpy as np
arr = np.random.rand(3)
print(arr)
# [0.19540265 0.05196615 0.19760922]

生成一个二维数组，元素值在0到1之间

import numpy as np
arr = np.random.rand(3,2)
print(arr)
# [[0.73464143 0.93573281]
# [0.60166518 0.8168656 ]
# [0.46130071 0.62225312]]

random.random()

原型：numpy.random.random(size=None)
作用：生成[0,1)之间的随机数

size	元素个数

生成0到1之间的随机数

import numpy as np
arr = np.random.random()
print(arr)
# 0.038177576025269944

生成一个有3个元素的一维数组，元素值在0到1之间

import numpy as np
arr = np.random.random(3)
print(arr)
# [0.89415182 0.41692305 0.05000384]

random.randint()

原型：randint(low,high=None,dtype="i")
作用：生成随机数

low	包含的下限
high	不包含的上限
size	元素个数
dtype	元素类型

import numpy as np
arr = np.random.randint(0,10,3)
print(arr)
# [1 3 8]

random.randn()

原型：numpy.random.randn(d0,d1,d2,,,dn)
作用：返回一个或一组样本，具有标准正态分布
标准正态分布：又称为u分布，是以0为均值，以1为标准差的正态分布，记为N(0,1)

import numpy as np
arr = np.random.randn()
print(arr)
# -0.8448995797110743
import numpy as np
arr = np.random.randn(2,4)
print(arr)
#[[ 1.013186   -0.16393337  1.04776331  0.04324756]
# [-1.21219629 -0.0699094  -0.04158484 -0.64842859]]
import numpy as np
arr = np.random.randn(4,3,2)
print(arr)
#[[[ 1.25923402 -0.50526673]
#  [-0.48671163 -0.56756381]
#  [-0.51491704  0.91395557]]

# [[-0.45384604  0.21068678]
#  [ 2.17285565 -2.27612329]
#  [-0.65976791 -0.75429788]]

# [[-0.79123359 -1.171368  ]
#  [ 0.43132159  0.8026211 ]
#  [ 0.05512591  0.96871725]]

# [[-0.22467091 -0.06629686]
#  [-0.4785244  -0.48309375]
#  [-1.03609105  0.21415391]]]

random.normal()

原型：numpy.random.normal(loc=0.0, scale=1.0, size=None)
作用：生成高斯分布的概率密度随机数

loc	浮点型，此概率分布的均值（对应着整个分布的中心）
scale	浮点型，此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越高瘦）
size	输出的shape，默认为None，只输出一个值

import numpy as np
arr = np.random.normal(loc=1, scale=2,size=5)
print(arr)
# [ 4.00300317 -3.78664425  0.42317672 -0.17428225  0.81371244]

3.numpy数组与python中列表的对比

效率对比

import random
import time
import numpy as np
li=[]
for i in range(1000000):
    li.append(i)
)
# python列表
t1 = time.time()
ret = sum(li)
t2 = time.time()
print(f"列表耗时:{t2-t1}")

# numpy数组 
n = np.array(li)
t1 = time.time()
ret = np.sum(n)
t2 = time.time()
print(f"数组耗时：{t2-t1}")
# 列表耗时:0.021838665008544922
# 数组耗时：0.0010006427764892578

4.Ndarray数组属性

Ndarray数组的维数称为秩（rank），一维数组的秩为1，二维数组的秩为2，以此类推。在NumPy中，每个线性的数组称为一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是Numpy中的轴（axis）,第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量--秩，就是数值的维数。很多时候可以声明axis。axis=0，表示沿着第0轴进行操作，即对每一列进行操作；axis=1，表示沿着第一轴进行操作，即对每一行进行操作。

ndim	秩，即轴的数量或维度的数量
shape	数组的维度，对于矩阵，n行m列
size	数组元素的总个数，相当于.shape中的n*m的值
dtype	ndarray对象的元素类型
itemsize	ndarray对象中每个元素的大小，以字节为单位
flags	ndarray对象的内存信息
real	ndarray对象的实部
imag	ndarray对象的虚部
data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性

ndim

import numpy as np
arr = np.arange(24)
print(arr)
print(arr.ndim)
# 调整维数，li现在拥有3个维度
li = arr.reshape(2,3,4)
print(li)
print(li.ndim)
"""
输出结果：
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
1
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
3
"""

shape

表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即ndim属性（秩）。比如，一个二维数组，其维度表示行数和列数

得到维度

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.shape)
"""
[[1 2 3]
 [4 5 6]]
(2, 3)
"""

调整数组大小

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
arr.shape = (3,2)
print(arr)
print(arr.shape)
"""
[[1 2]
 [3 4]
 [5 6]]
(3, 2)
"""

size

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.size)
"""
[[1 2 3]
 [4 5 6]]
6
"""

dtype

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.dtype)
"""
[[1 2 3]
 [4 5 6]]
int32
"""

itemsize

以字节的形式返回数组中每个元素的大小

import numpy as np
arr = np.array([1,2,3,4,5,6], dtype="i4")
print(arr)
print(arr.itemsize)
"""
[1 2 3 4 5 6]
4
"""

flags

返回ndarray对象的内存信息

C_CONTIGUOUS（C）	数据是在一个单一的C风格的连续段中
F_CONTIGUOUS(F)	数据是在一个单一的Fortran风格的连续段中
OWNDATA(O)	数组拥有它所使用的内存或者从另一个对象中借用它
WRITEABLE(W)	数据区域可以被写入，将该值设置为False，则数据为只读
ALIGNED(A)	数据和所有元素都适当的对齐到硬件上
UPDATEIFCOPY(U)	这个数组是其他数组的一个副本，当这个数组被释放时，原数组的内容将被更新

import numpy as np
arr = np.array([1,2,3,4,5])
print(arr)
print(arr.flags)
"""
[1 2 3 4 5]
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False
  """