numpy
数据类型
bool_ 存储为一个字节的布尔值
int_ 默认整数，相当于C的long，通常为int32或int64
intc 相当于C的int，通常为int32或int64
intp 用于索引的整数，相当于C的size_t，通常为int32或int64
int8 字节
int16 16位整数
int32 32位整数
int64 64位整数
uint8 8位无符号整数
uint16 16位无符号整数
uint32 32位无符号整数
uint64 64位无符号整数
float float64的简写
float16 半精度浮点：1个符号位 5个指数位， 10个尾数
float32 单精度浮点：1个符号位 8个指数位， 23个尾数
float64 双精度浮点：1个符号位 11个指数位， 52个尾数
complex complex128类型的简写
complex64 复数 由两个32位浮点数表示（实部和虚部）
complex128 复数 由两个64位浮点数表示（实部和虚部）
datatime64 日期时间类型
timedelta64 两个时间之间的间隔
‘b’：布尔值
‘i’：符号整数
‘u’：无符号整数
‘f’：浮点
‘c’：复数浮点
‘m’：时间间隔
‘M’：日期时间
‘O’：Python 对象
‘S’, ‘a’：字节串
‘U’：Unicode
‘V’：原始数据（void）
import numpy as np
# ndarray类
# 特点： 只能存储相同类型的数据；每个维度的元素数量必须一致
# 属性：
# T 返回经过转置的矩阵 ndim<2 返回原有数据
# data 用于表示数组中的数据从哪里开始的Python缓冲区对象
# dtype 元素的类型
# flags 数据在内存中的保存方式
# imag 虚数部分
# real 实数部分
# size 元素的数量
# itemsize 内存中每个元素以字节为单位的内存容量
# nbytes 所有元素在内存中占的字节数
# ndim 维度数
# shape 形状
# strides 在各个维度方向上移动到下一个相邻元素时所需移动的字节数
# ctypes 操作ctypes模块的迭代器
# base 基类对象 只要对象不是视图返回值一定是None
n1 = np.array([1,2,3])
n2 = np.array([[1,2,3], [4,5,6]])
print(type(n1))
print(n1.T)
print(n2.T)
print(n1.data)
print(n1.dtype)
print(n1.shape, n2.shape)
print(n1.ndim, n2.ndim)
print(n1.itemsize)
# flages:
# C_CONTIGUOUS (C) 数组位于单一的、C 风格的连续区段内 行主序 沿列方向依次进行存储
# F_CONTIGUOUS (F) 数组位于单一的、Fortran 风格的连续区段内 列主序 沿行方向依次进行存储
# OWNDATA (O) 数组的内存从其它对象处借用
# WRITEABLE (W) 数据区域可写入。 将它设置为flase会锁定数据，使其只读
# ALIGNED (A) 数据和任何元素会为硬件适当对齐
# UPDATEIFCOPY (U) 这个数组是另一数组的副本。当这个数组释放时，源数组会由这个数组中的元素更新
print(n1.flags)
<class 'numpy.ndarray'>
[1 2 3]
[[1 4]
[2 5]
[3 6]]
<memory at 0x00000297105F4880>
int32
(3,) (2, 3)
1 2
4
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
# 创建数组
# np.array(object, dtype, copy, order, subok, ndmin)
# object 任何具有数组接口方法的对象
# dtype 数据类型
# copy 默认为True 表示object对象被复制；否则只有当__array__返回副本，object参数为嵌套序列，或者需要副本满足数据类型和顺序要求时，才会生成副本
# order 元素在内存中出现的顺序，值为K A C F 如果object参数不是数组，则新创建的数组排序为C，如果F则按列排序；如果object是数组，则都成立C(按行),F(按列)，A（源顺序），K(元素在内存中出现的顺序)
# subok 如果为True则将传递子类，否则返回的数组将强制为基类数组（默认）
# ndmin 指定生成数组的最小维度
n1 = np.array([1,2,3,4], dtype=np.uint8)
# 创建三维数组
n2 = n1.reshape(1,1,4)
# 最小维度
n3 = np.array([1,2,3,4,5], ndmin=2)
print(n3)
[[1 2 3 4 5]]
# np.dtype(object, Align, Copy)
# object 被转换为数据类型的对象
# Align 如果为true，则向字段添加间隔，使其类似 C 的结构体
# Copy 生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用
dt = np.dtype([('age', np.uint8)])
n1 = np.array([1,2,3], dtype=dt)
print(n1.dtype)
print(n1)
print(n1['age'])
[('age', 'u1')]
[(1,) (2,) (3,)]
[1 2 3]
# 视图和副本
# 视图就是使用原数据的内存地址
a = np.array([1,2,3])
b = a
print(id(b) == id(a))
c = a.copy()
print(id(c) == id(a))
print(np.may_share_memory(a,c)) # 判断是副本还是视图
b[1] = 3
print(np.may_share_memory(a, b))
c[2] = 4
print(a, c)
True
False
False
True
[1 3 3] [1 2 4]
# 创建随机数
# np.random.rand() 创建0到1之间的随机数
# np.random.randint(start, end, size)
# 随机数固化处理
np.random.seed(42)
print(np.random.rand())
print(np.random.rand())
np.random.seed(42)
print(np.random.rand())
# 列表随机提取
# np.random.choice()
a = np.arange(10)
print(np.random.choice(a,4))
print(np.random.choice(a,4,replace=False)) # 不重复提取
print(np.random.choice(a,4,p=[0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1])) # p表示提取的概率 加起来是1
print(np.random.choice(10,10)) # 等同于print(np.random.choice(np.arange(10),10))
# 列表随机排序
print(a)
np.random.shuffle(a)
print(a)
# 生成服从特定概率的随机数
# np.random.randn() 生成服从标准正太分布的随机数
# np.random.normal(loc,scale,size) 生成其他正太分布的随机数 loc平均值 scale标准差
# np.random.binomial(n,p,size) 生成服从二项分布的随机数 n是执行的次数 p是概率 size表示此操作执行的次数
# np.random.beta(n,p,size) 生成服从贝塔分布的随机数
# np.random.gamma(shape,scale,size) 生成服从伽马分布的随机数
# np.random.poisson(n,size) 生成服从泊松分布的随机数
# np.random.chisquare(n, size) 生成服从卡方分布的随机数
0.3745401188473625
0.9507143064099162
0.3745401188473625
[7 4 6 9]
[0 1 8 5]
[0 7 9 0]
[4 0 9 5 8 0 9 2 6 3]
[0 1 2 3 4 5 6 7 8 9]
[5 3 1 6 0 7 9 4 2 8]
# 创建指定维度和数据类型未初始化的数组
# numpy.empty(shape, dtype = float, order = 'C')
# Order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组
n2 = np.empty([2,3],dtype=np.uint8)
n2
array([[0, 0, 0],
[0, 0, 0]], dtype=uint8)
# 创建纯0的数组
# numpy.zeros(shape, dtype = float, order = 'C')
n2 = np.zeros([2,3], dtype=np.uint8)
n2
n3 = np.zeros(n2.shape)
n4 = np.zeros_like(n2)
print(n3, n4)
[[0. 0. 0.]
[0. 0. 0.]] [[0 0 0]
[0 0 0]]
# 创建纯1的数组
# numpy.ones(shape, dtype = None, order = 'C')
n2 = np.ones([2,3], dtype=np.uint8)
n2
array([[1, 1, 1],
[1, 1, 1]], dtype=uint8)
# 创建单位数组 数组的对角线度是1
print(np.identity(5))
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
# 从现有数据创建数组
# numpy.asarray(a, dtype = None, order = None)
# a 任意形式的输入参数
x = [1,2,3]
n1 = np.asarray(x, dtype=np.uint8)
print(n1)
[1 2 3]
# 数组扁平化
# np.ndarray.flayyen(order) 将多维数组转换为一维数组
# np.ravel(a,order) 将多维数组转换为一维数组
# 数组铺开函数
# np.tile(a,reps) reps 表示平铺的次数
n = np.array([1,2,3])
print(np.tile(n, (3,3)))
[[1 2 3 1 2 3 1 2 3]
[1 2 3 1 2 3 1 2 3]
[1 2 3 1 2 3 1 2 3]]
# 判断数组真假
# np.all(arr, axis=None,out=None, keepdims=False) 判断数组元素是否全为True
# keepdims 默认False 表示返回数组是否保持原有的形状
# np.any(arr, axis=None,out=None, keepdims=False) 判断数组元素是否有为True的元素
# keepdims 默认False 表示返回数组是否保持原有的形状
# 创建对角线是1的数组
# a = np.eye(n,M,k,dtype)
# n 表示行数
# M 表示列数
# k 表示对角线索引
print(np.eye(5,5, 0))
print(np.eye(5,5,1))
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
[[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]
[0. 0. 0. 0. 0.]]
# 将缓冲区解释为一维数组
# numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
# buffer 任何暴露缓冲区接口的对象
# count 需要读取的数据数量，默认为-1，读取所有数据
# offset 需要读取的起始位置，默认为0
s = 'name'
a = np.frombuffer(s, dtype='S1')
# 从任何可迭代对象构建一个ndarray对象
# numpy.fromiter(iterable, dtype, count = -1)
# iterable 任何可迭代对象
a = range(3)
b = iter(a)
n1 = np.fromiter(b, dtype='i4')
print(n1)
[0 1 2]
# 从数值范围创建数组
# numpy.arange(start, stop, step, dtype)
# start 范围的起始值，默认为0
# stop 范围的终止值（不包含）
# step 两个值的间隔，默认为1
n1 = np.arange(0, 5, dtype='i1')
print(n1)
[0 1 2 3 4]
# linspace(线性等分向量)
# np.linspace(start,stop,num,endpoint=True,retstep=False,dtype=None)
# start 序列的起始值
# stop表示结束值 如果endpoint为true，该值包含于序列中
# num表示生成的元素个数
# endpoint表示是否包含结束值 True表示包含 默认为ture
# retstep 表示是否返回步长（或公差），False表示不返回，True表示返回 返回值是二元组（数列数组，步长）
a = np.linspace(0, 10, 10)
print(a)
a = np.linspace(0,10,10,retstep=True)
print(a)
print(a[0])
[ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556
6.66666667 7.77777778 8.88888889 10. ]
(array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ]), 1.1111111111111112)
[ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556
6.66666667 7.77777778 8.88888889 10. ]
# logspace(对数等分向量)
# np.linspace(start,stop,num,endpoint=True,base=10.0,dtype=None)
# start 起始值是base
# stop表示结束值 默认包含结束值
# num表示生成的元素个数
# endpoint表示是否包含结束值 True表示包含
# base 表示底数
a = np.logspace(0,9, 10, 10)
a
array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])
# 创建随机数组
# np.random.randint(low,high,size)
# low 随机数最小取值范围
# high 可选，随机数取值最大的范围
# size 数组维数
n2 = np.random.randint(1, 3, 10)
print(n2)
n1 = np.random.randint(5, 17)
print(n1)
n3 = np.random.randint(5, size=(2,3))
print(n3)
[1 1 1 2 1 2 2 2 2 1]
6
[[0 1 2]
[2 2 2]]
# 数组索引和切片
# 基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将start，stop和step参数提供给内置的slice函数来构造一个 Python slice对象。 此slice对象被传递给数组来提取数组的一部分。
# a = slice(start, stop, step)
# r = n[start:stop:step]
# step为负数时，代表反向索引
n1 = np.arange(10)
print(n1)
a = slice(2,3,1)
print(n1[a])
print(n1[2:7:2])
# 切片还可以包括省略号（...），来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的ndarray
n1 = np.arange(9).reshape(3,3)
print(n1)
print(n1[1:])
print(n1[..., 1])
print(n1[0, ...])
[0 1 2 3 4 5 6 7 8 9]
[2]
[2 4 6]
[[0 1 2]
[3 4 5]
[6 7 8]]
[[3 4 5]
[6 7 8]]
[1 4 7]
[0 1 2]
# 指定条件获得数组索引
# np.where(condition([,x,y])) 返回所提取的ndarray元素的索引
# 如果指定x,y 就会返回元素被转换成x或y的darray
a = np.arange(12).reshape(3,4)
b = np.where(a>3)
print(b)
print(a[b])
# 指定x, y, 必须对x,y都指定 否则会报错
c = np.where(a%2==0, 'even','old')
print(c)
# 筛选非零的函数
# np.nonzero() 返回一维数组
(array([1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
[ 4 5 6 7 8 9 10 11]
[['even' 'old' 'even' 'old']
['even' 'old' 'even' 'old']
['even' 'old' 'even' 'old']]
### 高级索引
# 整数索引
n1 = np.arange(9).reshape(3,3)
print(n1)
x = n1[[1,2,0], [1,2,0]]
# 表示分别提取（1，1）， （2，2）， (0,0)的数据
print(x)
rows = np.array([[0,2], [0,1]])
cols = np.array([[1,0], [0,1]])
# 分别提起(0,1), (2,0), (0,0), (1,1)的数据
print(n1[rows, cols])
print(n1[1:, :1])
# 进行切片索引
print(n1[:1, [0,2]])
# 布尔索引
print(n1[n1<4])
a = np.array([1, 2+6j, 5, 3.5+5j])
print(a[np.iscomplex(a)])
[0 1 2 3]
[2. +6.j 3.5+5.j]
# 广播
# 广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行
# 如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容
# 如果两个素组维度不相等，维度较低的数组的形状会从左侧开始填充1，直到维度和高维度数组相等
# 如果两个数组维度相等，要么对应轴的长度相同，要么其中一个长度为1，则是兼容数组可以广播，长度为1的轴会被扩展。
# 如果不满足上述两个条件 则会报错
n1 = np.arange(9).reshape(3,3)
n2 = np.array([1,2, 3])
print(n1+n2)
[[ 1 3 5]
[ 4 6 8]
[ 7 9 11]]
# 数组上的迭代
# 包含一个迭代器对象numpy.nditer
# np.nditer(object, order， op_flags， flags)
# order顺序的不同，迭代数据的排序也不同
# op_flags 表示权限 默认是只读 也可以是读写
# flags参数：
# c_index 可以跟踪 C 顺序的索引
# f_index 可以跟踪 Fortran 顺序的索引
# multi-index 每次迭代可以跟踪一种索引类型
# external_loop 给出的值是具有多个值的一维数组，而不是零维数组
for i in np.nditer(n1):
print(i)
0
1
2
3
4
5
6
7
8
# 广播迭代
# 如果两个数组是可广播的，nditer组合对象能够同时迭代它们。 假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器（数组b被广播到a的大小）
n2 = np.array([6,7,8])
for x,y in np.nditer([n1, n2]):
print(x,y)
0 6
1 7
2 8
3 6
4 7
5 8
6 6
7 7
8 8
# 数组操作
# np.reshape(a,newshape, order)
# reshape 不改变数据的条件下修改形状 共享内存 若数量不一致会报错
n1 = np.array([1,2,3,4])
n2 = n1.reshape(2,2)
print(n2)
# np.resize(a,newshape)
# 使用resize不共享内存 即使数量不一致也会强制执行 对欠缺的元素用原有的元素进行补充
# ndarray.resize(newshape,refcheck)
# refcheck是否检查引用计数器 若True则如果数量不一致会报错，否则不会并对欠缺的元素用0补充 默认为True
#
# 在数组末端添加数组
# np.append(arr,values,axis=None)
# 若不指定axis，则返回一维数组
# 若指定axis， 如果添加的元素形状不一致会报错
# flat 数组上的一维迭代器
print(n2.flat[3])
# flatten 返回折叠为一维的数组副本
# ndarray.flatten(order)
n3 = n2.flatten()
print(n3)
# ravel 展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型
# ndarray.ravel(order)
n4 = n2.ravel()
print(n4)
# 翻转操作
# transpose 翻转数组的维度
# numpy.transpose(arr, axes)
# arr 表示需要翻转的数组
# axes 整数的列表，对应维度
n1 = np.arange(18).reshape(2,3, 3)
print(n1)
n2 = np.transpose(n1, (0,2,1))
print(n2)
# ndarray.T
print(n1.T)
# numpy.rollaxis(arr, axis, start)
# 向后滚动特定的轴，直到一个特定位置
# 将arr的axis轴移动到start的前面 start轴往后移动一
n1 = np.arange(8).reshape(2,2,2)
print(np.rollaxis(n1, 2))
# numpy.swapaxes(arr,axis1,axis2)
# 交换数组的两个轴
n1 = np.arange(8).reshape(2,2,2)
print(np.swapaxes(n1, 1,2))
[[1 2]
[3 4]]
4
[1 2 3 4]
[1 2 3 4]
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]]
[[[ 0 3 6]
[ 1 4 7]
[ 2 5 8]]
[[ 9 12 15]
[10 13 16]
[11 14 17]]]
[[[ 0 9]
[ 3 12]
[ 6 15]]
[[ 1 10]
[ 4 13]
[ 7 16]]
[[ 2 11]
[ 5 14]
[ 8 17]]]
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
7
# 修改维度
# broadcast 产生模仿广播的对象
n1 = np.array([[1],[2],[3]])
n2 = np.array([4,5,6])
b = np.broadcast(n1, n2)
print(b.shape)
for i in b:
print(i)
# broadcast_to 将数组广播到新形状
# numpy.broadcast_to(array, shape, subok)
n1 = np.arange(4).reshape(1,4)
print(n1)
n2 = np.broadcast_to(n1,(4,4))
print(n2)
# expand_dims 扩展数组形状 通过在指定位置插入新的轴来扩展数组形状
# numpy.expand_dims(arr, axis)
n1 = np.array([1,2,3])
n2 = np.expand_dims(n1, axis=0)
print(n2)
# squeeze 从数组的形状中删除单维度的条目 从给定数组的形状中删除一维条目
# numpy.squeeze(arr, axis)
# axis 整数或整数元组，用于选择形状中单一维度条目的子集
n3 = np.squeeze(n2)
print(n3)
(3, 3)
(1, 4)
(1, 5)
(1, 6)
(2, 4)
(2, 5)
(2, 6)
(3, 4)
(3, 5)
(3, 6)
[[0 1 2 3]]
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
[[1 2 3]]
[1 2 3]
# 数组连接
# concatenate 沿着现存的轴连接数据序列
# numpy.concatenate((a1, a2, ...), axis)
# a1,a2...表示相同类型的数组序列
a1 = np.array([1,2,3])
a2 = np.array([3,2,1])
a3 = np.concatenate((a1,a2))
print(a3)
# stack 沿着新轴连接数组序列
# numpy.stack(array,axis)
# array 表示相同的数组序列
# axis 返回数组中的轴，输入数组沿着它来堆叠
a4 = np.stack((a1,a2))
print(a4)
# hstack 水平堆叠序列中的数组（列方向）
a5 = np.hstack((a1, a2))
print(a5)
# vstack 竖直堆叠序列中的数组（行方向）
a6 = np.vstack((a1,a2))
print(a6)
# np.r_[a,b] 不是函数 功能类似于np.hstack()
# np.r_[start:stop,step]创建数组
# np.r_['a,b,c', a,b] a表示连接的维度， b表示生成的维度数 c表示shape
[1 2 3 3 2 1]
[[1 2 3]
[3 2 1]]
[1 2 3 3 2 1]
[[1 2 3]
[3 2 1]]
# 分割数组
# split函数沿指定轴分割多个数组
# np.split(ary, indices_or_sections, axis)
# indices_or_sections是一个整数或数组，如果是整数就用该数平均分割，如果是数组，就沿指定轴切片操作（包含开始开始 不包含结束）
# 如果是整数不能整数分割就会出错
a = np.arange(0, 9)
b = np.split(a,3)
print(b)
c = np.split(a,[2,6])
print(c)
d = np.arange(0,9).reshape((3,3))
print(d)
f = np.split(d, 3)
print(f)
g = np.split(d, 3, axis=1)
print(g)
# hsplit 将数组水平分割为多个数组
n = np.hsplit(d,3)
print(n)
# vsplit 将数组垂直分割为多个数组
m = np.vsplit(d,3)
print(m)
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
[array([0, 1]), array([2, 3, 4, 5]), array([6, 7, 8])]
[[0 1 2]
[3 4 5]
[6 7 8]]
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
# 添加/删除元素
# resize 返回指定形状的新数组
# numpy.resize(arr, shape)
n1 = np.arange(8)
n2 = np.resize(n1,(2,4))
print(n2)
# 若尺寸过大，部分数据会反复出现
n3 = np.resize(n1, (3,3))
print(n3)
# append 将值添加到数组末尾
# numpy.append(arr, values, axis)
# values：要向arr添加的值，比如和arr形状相同（除了要添加的轴）
# axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开
n5 = np.array([2,3,4,5])
n6 = np.append(n2, n5)
print(n6)
n7 = np.append(n2, n5.reshape(1,4), axis=0)
print(n7)
# insert 沿指定轴将值插入到指定下标之前
# numpy.insert(arr, obj, values, axis)
# obj 在其之前插入值的索引
# values：要插入的值
# axis：沿着它插入的轴，如果未提供，则输入数组会被展开
a = np.array([[1,2], [4,3]])
b = np.insert(a,2, [3,4])
print(b)
c= np.insert(a,2,[3,4], axis=0)
print(c)
d = np.insert(a,2, [3,4], axis=1)
print(d)
# delete 返回删掉某个轴的子数组的新数组
# numpy.delete(arr, obj, axis)
# obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
# axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
b = np.delete(a,2)
print(b)
c = np.delete(a,1, axis=0) # 删除第二行
print(c)
n = np.arange(10)
m = np.delete(n,np.s_[::2])
print(m)
print(np.s_[::2])
# unique 寻找数组内的唯一元素
# numpy.unique(arr, return_index, return_inverse, return_counts)
# return_index：如果为true，返回输入数组中的元素下标
# return_inverse：如果为true，返回去重数组的下标，它可以用于重构输入数组
# return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
a = np.array([5,2,6,2,7,5,6,8,2,9])
b = np.unique(a)
print(b)
c = np.unique(a,return_index=True)
print(c)
d = np.unique(a, return_inverse=True)
print(d)
f= np.unique(a,return_counts=True)
print(f)
[[0 1 2 3]
[4 5 6 7]]
[[0 1 2]
[3 4 5]
[6 7 0]]
[0 1 2 3 4 5 6 7 2 3 4 5]
[[0 1 2 3]
[4 5 6 7]
[2 3 4 5]]
[1 2 3 4 4 3]
[[1 2]
[4 3]
[3 4]]
[[1 2 3]
[4 3 4]]
[1 2 3]
[[1 2]]
[1 3 5 7 9]
slice(None, None, 2)
[2 5 6 7 8 9]
(array([2, 5, 6, 7, 8, 9]), array([1, 0, 2, 4, 7, 9], dtype=int64))
(array([2, 5, 6, 7, 8, 9]), array([1, 0, 2, 0, 3, 1, 2, 4, 0, 5], dtype=int64))
(array([2, 5, 6, 7, 8, 9]), array([3, 2, 2, 1, 1, 1], dtype=int64))
# 位操作
# bitwise_and 对数组元素执行位与操作
a = 13
b = 15
print(bin(a), bin(b))
c = np.bitwise_and(a,b)
print(c)
# bitwise_or 对数组元素执行位或操作
d = np.bitwise_or(a, b)
print(d)
# invert 计算位非
f = np.invert(a)
print(f)
print(np.binary_repr(f, width=8))
# left_shift 向左移动二进制表示的位
# right_shift 向右移动二进制表示的位
0b1101 0b1111
13
15
-14
11110010
# 字符串函数
# add() 返回两个str或Unicode数组的逐个字符串连接
# numpy.char.add()
print(np.char.add(['hell'], ['ow']))
print(np.char.add([['123', 'ert'], ['111', '223']], [['123', 'ert'], ['111', '223']]))
# multiply() 返回按元素多重连接后的字符串
print(np.char.multiply('123', 4))
# center() 返回给定字符串的副本，其中元素位于特定字符串的中央 返回所需宽度的数组，以便输入字符串位于中心，并使用fillchar在左侧和右侧进行填充
# np.char.center(arr, width,fillchar)
print(np.char.center('hll', width=10, fillchar='.'))
# capitalize() 返回给定字符串的副本，其中只有第一个字符串大写
print(np.char.capitalize('hell'))
# title() 返回字符串或 Unicode 的按元素标题转换版本
print(np.char.title('are you ready?'))
# lower() 返回一个数组，其元素转换为小写
print(np.char.lower('Are you ready?'))
# upper() 返回一个数组，其元素转换为大写
print(np.char.upper('are you ready?'))
# split() 返回字符串中的单词列表，并使用分隔符来分割
print(np.char.split('are you ready?', ' '))
# splitlines() 返回元素中的行列表，以换行符分割
print(np.char.splitlines('are\nyou ready?'))
# strip() 返回数组副本，其中元素移除了开头或者结尾处的特定字符
print(np.char.strip('are you ready? '))
# join() 返回一个字符串，它是序列中字符串的连接
print(np.char.join([':'], ['dim']))
# replace() 返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代
print(np.char.replace('are you ready?', 'you', 'I'))
# decode() 按元素调用str.decode
# encode() 按元素调用str.encode
['hellow']
[['123123' 'ertert']
['111111' '223223']]
123123123123
...hll....
Hell
Are You Ready?
are you ready?
ARE YOU READY?
['are', 'you', 'ready?']
['are', 'you ready?']
are you ready?
['d:i:m']
are I ready?
# 算术函数
# 三角函数
a = np.array([0,30,60,90])
# 通过乘以pi/180转化为弧度
print(np.sin(a*np.pi/180))
print(np.cos(a*np.pi/180))
print(np.tan(a*np.pi/180))
sin = np.sin(a*np.pi/180)
print(np.arcsin(sin)) # 反转为弧度
print(np.degrees(np.arcsin(sin))) # 通过弧度转换为角度
# 舍入函数
# 返回四舍五入到所需精度的值
a = np.around(2.3344, 2)
print(a, type(a), type(int(a)))
# 返回不大于输入参数的最大整数 即标量x 的下限是最大的整数i ，使得i <= x
a = np.array([0.2, -1.3, 5.4])
print(np.floor(a))
# 返回输入值的上限 标量x的上限是最小的整数i ，使得i> = x
print(np.ceil(a))
# 角度和弧度转换
# np.radians() 将角度换算为弧度
# np.red2deg() 将弧度换算为角度
# np.deg2rad() 将角度换算为弧度
[0. 0.5 0.8660254 1. ]
[1.00000000e+00 8.66025404e-01 5.00000000e-01 6.12323400e-17]
[0.00000000e+00 5.77350269e-01 1.73205081e+00 1.63312394e+16]
[0. 0.52359878 1.04719755 1.57079633]
[ 0. 30. 60. 90.]
2.33 <class 'numpy.float64'> <class 'int'>
[ 0. -2. 5.]
[ 1. -1. 6.]
# 点积 两个数字序列的相应的条目的乘积之和
# 叉积 \\a\\\\\b\sin@n
# 内积
# 外积 张量积 如果这两个向量的维度是n和m，那么它们的外积是一个n × m矩阵
# 算术运算 输入数组必须具有相同的形状或符合数组广播规则
# 数组加法 减法 除法 乘法
a = np.array([1,2,3], np.float32)
b = np.array([4,5,6])
c = np.add(a, b)
print(c)
d = np.subtract(b, a)
print(d)
f = np.multiply(a, b)
print(f)
g = np.divide(b, a)
print(g)
# 返回数组的倒数
print(np.reciprocal(a))
# 幂运算
a = np.array([1,2,3])
b = np.array([2,2,2])
c = np.power(a,b)
print(c)
# 返回输入数组中相应元素的除法余数
print(np.mod(a,b))
# 差分计算
# np.diff(a,n,axis)
# 将数组中的元素相加之后保存到数组中
# np.cumsum(a,axis,dtype,out)
n1 = np.arange(10)
print(n1.cumsum())
# 指数
# np.exp()
# 对数
# np.log()
# 常数
# np.pi = 3.1415926
# np.e = 2.7182818
# 对于复数的数组执行操作：
# numpy.real() 返回复数类型参数的实部。
# numpy.imag() 返回复数类型参数的虚部。
# numpy.conj() 返回通过改变虚部的符号而获得的共轭复数。
# numpy.angle() 返回复数参数的角度。 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示
[5. 7. 9.]
[3. 3. 3.]
[ 4. 10. 18.]
[4. 2.5 2. ]
[1. 0.5 0.33333334]
[1 4 9]
[1 0 1]
[ 0 1 3 6 10 15 21 28 36 45]
# 统计函数
# np.amax(a,axis=None,out=None. keepdims=np.NoValue)
# keepdims 为True时表示返回值与原数组有相同的维度
# numpy.amin() numpy.amax() 从给定数组中的元素沿指定轴返回最小值和最大值
# ndarray.max(axis=None,out=None,keeodims=np.NoValue) 若元素中有nan则最大值为nan，可通过nanmax()函数进行排除
a = np.array([1,2,3,4,2,6]).reshape(2,3)
print(a)
print(a.min())
print(np.amin(a, axis=1))
# 返回包含多维数组中最大值元素的索引
# ndarray.argmax(axis=None,out=None)
# np.argmax(a,axis=None,out=None)
print(a.argmax())
# numpy.ptp() 返回沿轴的值的范围（最大值 - 最小值）
print(np.ptp(a))
print(np.ptp(a,axis=0))
print(np.ptp(a,axis=1))
# numpy.percentile(a, q, axis)
# a 表示输入数组
# q 表示要计算的百分位数
a = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(a)
print(np.percentile(a, 50))
print(np.percentile(a, 50, axis=0))
print(np.percentile(a,50,axis=1))
# numpy.median() 中值定义为将数据样本的上半部分与下半部分分开的值
# np.average(a,axis,wights,rerurned) weights表示计算时该元素占的比重 returned表示以元组的形式返回平均值和权重的合计值
print(np.median(a))
print(np.median(a,axis=1))
print(np.median(a,axis=0))
# numpy.mean() 算术平均值 沿轴的元素的总和除以元素的数量
print(np.mean(a))
print(np.mean(a,axis=0))
print(np.mean(a,axis=1))
# numpy.average() 加权平均值是由每个分量乘以反映其重要性的因子得到的平均值
# numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开
a = np.array([1,2,3,4])
wts = np.array([4,3,2,2])
print(np.average(a, weights=wts))
print(np.average(a, weights=wts, returned=True)) # returned=True 表示返回权重和
# 标准差
# 标准差是与均值的偏差的平方的平均值的平方根
# std = qprt(mean((x-x.mean())**2))
import math
a = np.arange(1, 10)
a = a.astype(np.float32)
a_mean = np.mean(a)
a_std = math.sqrt(np.mean(np.power(a-a_mean, 2)))
print(a_std)
print(np.std(a))
# 方差
# 偏差的平方的平均值
# np.var() = np.std ** 2
print(a_std**2)
print(np.std(a) **2)
print(np.var(a))
[[1 2 3]
[4 2 6]]
1
[1 2]
5
[3 0 3]
[2 4]
[[1 2 3]
[4 5 6]
[7 8 9]]
5.0
[4. 5. 6.]
[2. 5. 8.]
5.0
[2. 5. 8.]
[4. 5. 6.]
5.0
[4. 5. 6.]
[2. 5. 8.]
2.1818181818181817
(2.1818181818181817, 11.0)
2.581988866691905
2.5819888
6.666666507720947
6.666666222674621
6.6666665
# 排序 搜索和计数
# numpy.sort(a,axis=-1, kind, order)
# axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
# kind 默认为'quicksort'（快速排序） 'mergesort'（归并排序） 'heapsort'（堆排序）
# order 如果数组包含字段，则是要排序的字段
a = np.arange(9).reshape(3,3)
print(np.sort(a))
# numpy.argsort()
# 对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组
x = np.array([3,2,1])
print(np.argsort(x))
print(x[np.argsort(x)])
# numpy.lexsort() 使用键序列执行间接排序
nm = ('raju','anil','ravi','amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv,nm))
print(ind)
# 分别沿给定轴返回最大和最小元素的索引
print(np.argmin(a,axis=0))
print(np.argmin(a))
# numpy.nonzero()
# 返回输入数组中非零元素的索引
print(np.nonzero(a))
print(a[np.nonzero(a)])
# numpy.where 返回数组中满足给定条件的元素的索引
print(np.where(a > 4))
# numpy.extract()
# 返回满足任何条件的元素
condition = a > 4
print(np.extract(condition, a))
[[0 1 2]
[3 4 5]
[6 7 8]]
[2 1 0]
[1 2 3]
[3 1 0 2]
[0 0 0]
0
(array([0, 0, 1, 1, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 1, 2, 0, 1, 2], dtype=int64))
[1 2 3 4 5 6 7 8]
(array([1, 2, 2, 2], dtype=int64), array([2, 0, 1, 2], dtype=int64))
[5 6 7 8]
# 字节交换
# 高低字节互换
a = np.array([1,21,3,4], np.int8)
print (hex(1)) # 对数组a逐个进行16进制转换
print(a.byteswap(True))
0x1
[ 1 21 3 4]
# 副本和视图
# 当内容物理存储在另一个位置时，称为副本。 另一方面，如果提供了相同内存内容的不同视图，我们将其称为视图。
# 无复制 赋值
a = np.array([1,1,2])
print(a)
print(id(a))
b = a
print(id(b))
# 视图 浅复制 可以更改维度，但数据保持一致
c = np.expand_dims(a, axis=0)
print(c)
print(id(c))
c[:,1] = 3
print(a)
# 深复制 它是数组及其数据的完整副本，不与原始数组共享
d = a.copy()
d[1] = 4
print(a, d)
[1 1 2]
1787653179312
1787653179312
[[1 1 2]]
1787653240656
[1 3 2]
[1 3 2] [1 4 2]
# 中位数
# 将数据从小到大排序后的中间值 如果是奇数个则正好是中间个 如果偶数个则取平均值
# numpy.median(a, axis,out,overwrite_input, keepdims)
# out表示输出结果
# keepdims表示输出值保持和输入的维度一致
# overwrite_input 覆盖在输入值上进行计算
n = np.random.randint(100, size=(3, 4))
print(n)
n_med = np.median(n)
print(n_med)
print(np.median(n, axis=1))
[[11 11 20 74]
[15 45 74 75]
[75 47 68 7]]
46.0
[15.5 59.5 57.5]
# 元素求和
# np.sum(a, axis, dtype, out, keepdims)
# dtype 指定输出数组的类型
n1 = np.random.randint(14, size=(3,4))
n2 = np.random.randint(14, 30, size=(3,4))
print(n1)
n3 = np.sum(n1)
print(n3)
print(n1.sum())
[[12 11 4 4]
[ 3 12 9 10]
[ 3 2 10 0]]
80
80
# 计算标准差
# 数据与平均值的差值的平方的平均数取平方根
# numpy.std(a,axis, dtype, out, ddof, keepdims)
# ddof 在计算标准差对数据的个数不是N 而是N-ddof
n = np.random.randint(100, size=(10,))
print(n)
n_std = np.std(n)
print(n_std)
n_std_1 = np.std(n, ddof=1)
print(n_std_1)
[ 0 39 39 84 16 72 88 16 92 83]
33.02559613390802
34.81203495600017
# 计算方差 用于表示数据的偏离程序的指标
# 将数据与平均值的差的平方进行平均得到的值
# numpy.var(a, axis,dtype, out, ddof, keepdims)
n_var = np.var(n)
print(n_var)
1090.69
# 计算协方差函数 用于表示两组相对应的数据集合之间在彼此相互影响的过程中数据分散程度的一种指标
# numpy.cov(a, y=None, rowvar=True, bias=False, ddof=None, fweights=None,aweights=None)
# y表示用于指定添加到a中的值 需要与a中的数据集有相同的形状
# rowvar 将每一行堪称一个数据集 在每一行之间计算协方差
# bais计算无偏协方差 将平均值与偏差的乘积和除以数量-1
# fweights 设置没观测一次时所赋予的权重
# aweights 用于指定赋予各个数据集合的权重
a = np.array([[10,5,2,4,9,3,2],[10,2,8,3,7,4,1]])
n_var = np.var(a, axis=1)
print(n_var)
n_cov = np.cov(a, bias=True)
print(n_cov)
[9.14285714 9.71428571]
[[9.14285714 5.71428571]
[5.71428571 9.71428571]]
# 计算相关系数的函数 用于表示两组数据之间的相关程度的指标
# np.corrcoef(x,y=None,rowvar=True, bias=_NoValue,ddof=_NoValue)
# rowvar 计算每一行的相关系数
print(np.corrcoef(a))
[[1. 0.60633906]
[0.60633906 1. ]]
# 根据数组元素生成网格
# numpy.meshgrid(x1,x2,x3...,xn, indexing='xy', sparse=false, copy=True)
# indexing 用于指定生成的数组的shape应当如何设置
# sparse 如果是True则会返回稀疏网格
a = np.array([1,2,3])
b = np.array([4,5])
aa, bb = np.meshgrid(a,b)
print(aa, bb)
import matplotlib.pyplot as plt
x = np.linspace(-2,2, 100)
y = np.linspace(-2,2, 100)
xx, yy = np.meshgrid(x,y)
ret = np.sin(xx**2 + yy**2)
plt.gca().set_aspect('equal', adjustable='box')
plt.contourf(xx,yy,ret>0,camp=plt.cm.bone)
plt.show()
[[1 2 3]
[1 2 3]] [[4 4 4]
[5 5 5]]
C:\Users\JX1402006\AppData\Local\Temp\ipykernel_120812\324455288.py:15: UserWarning: The following kwargs were not used by contour: 'camp'
plt.contourf(xx,yy,ret>0,camp=plt.cm.bone)
# 内积计算
# numpy.dot(a, b, out=None)
a = np.array([1,2])
b = np.array([2,3])
print(np.dot(a, b))
a1 = np.matrix([1,2])
b1 = np.matrix([[2],[3]])
print(np.dot(a1,b1))
a2 = np.array([[1,2],[3,4]])
b2 = np.array([[1,1], [1,1]])
print(np.dot(a2,b2))
8
[[8]]
[[3 3]
[7 7]]
# 计算行列式函数
# numpy.linalg.det(a)
n = np.arange(9).reshape(3,3)
print(n)
print(np.linalg.det(n))
[[0 1 2]
[3 4 5]
[6 7 8]]
0.0
# 计算矩阵的特征值和特征向量
# numpy.linalg.eig(a)
n = np.array([[1,2], [0,1]])
print(np.linalg.eig(n))
(array([1., 1.]), array([[ 1.00000000e+00, -1.00000000e+00],
[ 0.00000000e+00, 1.11022302e-16]]))
# 计算矩阵的秩
# numpy.linalg.matrix_rank(M, tol=None, hermitian=False)
# tol 用于在计算秩时，被当作0的元素的阈值
n = np.array([[1,1,4,0,1], [0,3,1,3,2], [1,3,0,0,1], [2,4,3,1,1]])
a = np.linalg.matrix_rank(n)
print(a)
4
# 计算逆矩阵
# numpy.linalg.inv(a)
# 计算外积 将两个向量的所有元素相乘的张量积
# numpy.outer(a,b, out=None)
a = np.random.randint(9, size=(4,))
b = np.arange(0,9)
print(np.outer(a,b))
[[ 0 6 12 18 24 30 36 42 48]
[ 0 3 6 9 12 15 18 21 24]
[ 0 0 0 0 0 0 0 0 0]
[ 0 7 14 21 28 35 42 49 56]]
# 计算叉积
# numpy.cross(a,b,axisa=-1, axisb=-1,axisc=-1,axis=None)
# 计算卷积积分和移动平均
# numpy.convolve(a,v,mode='full')
a = np.arange(5)
b = np.array([0,2, 0.8])
print(np.convolve(a,b))
x= np.linspace(0,10, 500)
y1 = np.sin(x)
y2 = y1 + np.random.randn(500)*0.3
v= np.ones(5)/5.0
y3=np.convolve(y1,v, mode='same')
plt.plot(x,y1,'k',linestyle='solid',linewidth=2)
plt.plot(x,y2,'b',linestyle='dotted',linewidth=1)
plt.plot(x,y3,'r',linestyle='solid',linewidth=2)
plt.show()
[ 0. 0. 2. 4.8 7.6 10.4 3.2]
# 矩阵库 模块的函数返回矩阵而不是返回ndarray对象
# numpy.matlib.empty(shape, dtype, order)
import numpy.matlib as nm
print(nm.empty((2,2), dtype=np.uint8))
print(nm.zeros((2,2)))
print(nm.ones((2,2)))
print(nm.eye(5,5,0))
print(nm.identity(5))
print(nm.rand(3,3))
[[0 0]
[0 0]]
[[0. 0.]
[0. 0.]]
[[1. 1.]
[1. 1.]]
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
[[0.58919189 0.78633791 0.50001837]
[0.65777148 0.68988401 0.75789893]
[0.85777162 0.36769645 0.27663127]]
# 线性代数
# dot 两个数组的点积
a = np.array([[1,2], [3,4]])
b = np.array([[11,12], [13,14]])
print(np.dot(a,b)) # [[1*11+2*13,1*12+2*14],[3*11+4*13, 3*12+4*14]]
# vdot 两个向量的点积
print(np.vdot(a,b)) # 1*11+2*12+3*13*4*14
# inner 两个数组的内积 返回一维数组的向量内积。 对于更高的维度，它返回最后一个轴上的和的乘积
print(np.inner(np.array([1,2,3]), np.array([2,2,2]))) # 1*2+2*2+3*2
# matmul 两个数组的矩阵积 返回两个数组的矩阵乘积
a = np.array([[1,0],[0,1]])
b= np.array([[1,2],[3,4]])
print(np.matmul(a, b))
# determinant 数组的行列式
print(np.linalg.det(b)) # 1*4-2*3
c = np.arange(9).reshape(3,3)
print(np.linalg.det(c))
# solve 求解线性矩阵方程
# inv 寻找矩阵的乘法逆矩阵
[[37 40]
[85 92]]
130
12
[[1 2]
[3 4]]
-2.0000000000000004
0.0
# histogram 获取输入数组的边界
a = np.random.randint(100, size=[10,])
print(a)
hist, bins = np.histogram(a, bins=[0,20,40,60,80,100])
print(hist)
[ 2 74 23 92 38 57 20 23 1 91]
[2 4 1 1 2]
# load save
# loadtxt savetxt
# numpy 支持加载和保存npy文件
# np.loadtxt(filename,dtype,comments,delimiter,converters,skiprows,usecols,unpack,ndim,encoding)
# comments 指定文件中注释部分的字符
# delimiter 表示值之间的分隔符 默认空格
# converters 指定在某个列中使用函数活用于填充缺失数据的值
# skiprows 用于指定读取时需要跳过的函数
# usecols 指定读取哪一行
# unpack 若为True，输出的数组会被转置
# ndmin 指定返回的数组应保持的最低维度
# encoding 用于指定读取文件时所使用的字符编码
# np.savetxt(filename,X,fmt,delimiter,newline,header,footer,comments,encoding)
# fmt 指定各个列上的有效位数
# header footer分别表示开头和结尾部分要插入的字符串
# np.genfromtxt() 性能优于np.loadtxt()
#
# 将buffer快速转换为np.ndarray的函数
# np.frombuffer(buffer,dtype,count,offset)
# count 表示读取的个数 -1表示全部读取
# offset 表示从哪个位置开始读取
# Matplotlib
#
# 字符 描述
# '-' 实线样式
# '--' 短横线样式
# '-.' 点划线样式
# ':' 虚线样式
# '.' 点标记
# ',' 像素标记
# 'o' 圆标记
# 'v' 倒三角标记
# '^' 正三角标记
# '<' 左三角标记
# '>' 右三角标记
# '1' 下箭头标记
# '2' 上箭头标记
# '3' 左箭头标记
# '4' 右箭头标记
# 's' 正方形标记
# 'p' 五边形标记
# '*' 星形标记
# 'h' 六边形标记 1
# 'H' 六边形标记 2
# '+' 加号标记
# 'x' X 标记
# 'D' 菱形标记
# 'd' 窄菱形标记
# `' '` 竖直线标记
# '_' 水平线标记
# 还定义了以下颜色缩写。
# 字符 颜色
# 'b' 蓝色
# 'g' 绿色
# 'r' 红色
# 'c' 青色
# 'm' 品红色
# 'y' 黄色
# 'k' 黑色
# 'w' 白色
from matplotlib import pyplot as plt
x = np.arange(180)
y = np.sin(x * np.pi / 180)
plt.title('demo')
plt.grid(True) # 添加网格
plt.xlabel('x')
plt.xlim(0,1) # 设置取值范围
plt.ylabel('y')
plt.plot(x,y, 'ob')
plt.show()
# subplot 允许在同一张图中绘制不同的东西
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
plt.subplot(3,1,1)
plt.plot(x, y_sin)
plt.title('Sine')
plt.subplot(2,1,2)
plt.plot(x, y_cos)
plt.title('cos')
Text(0.5, 1.0, 'cos')
# bar 生成条形图
# from matplotlib import pyplot as plt
x = [5,8,10]
y = [12,16,6]
x2 = [6,9,11]
y2 = [6,15,7]
plt.bar(x, y, align = 'center')
plt.bar(x2, y2, color = 'g', align = 'center')
plt.title('Bar graph')
plt.ylabel('Y axis')
plt.xlabel('X axis')
plt.show()
# 创建一个一维数组
a = np.array([1,2,3])
b = np.array((1,2,3))
c= np.array([1, 2],dtype=np.int_)
d= np.array([True, False])
e = np.array([1+2j, 2+3j]) # 复数类型
f = np.array(['1', '2'])
print(a, b)
print(type(a))
print(c.dtype) # 获取元素的数据类型
print(d.dtype)
print(e.dtype)
print(f.dtype)
[[[214 200 235]
[254 233 246]
[243 246 232]
[207 223 203]]
[[234 203 232]
[240 219 205]
[232 219 239]
[249 246 239]]
[[252 226 222]
[246 211 244]
[250 235 235]
[235 238 241]]]
# 类型代码
a = np.array(['1', '2'], dtype='S')
a
dt = np.dtype('<u4')
b = np.array([1, 2, 3], dt)
b
array([1, 2, 3], dtype=uint32)
# 数据类型转换
a = b.astype(np.float_)
print(a)
print(a.dtype)
[1. 2. 3.]
float64
# 更多方式创建一维数组
# 标量（单一数据） 向量（一维数组） 矩阵（二维数组） 张量（多维数组）
a = np.arange(1,5,dtype='i1')
print(a)
[1 2 3 4]
[ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556
6.66666667 7.77777778 8.88888889 10. ]
(array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ]), 1.1111111111111112)
[ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556
6.66666667 7.77777778 8.88888889 10. ]
array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])
# 创建二位数组 行和列
a = np.array([[1,2,3],[2,3,4]])
print(a)
print(a.shape)
print(a[0][0])
# 重新设置维度
b=a.reshape(3,2)
b
c = a.reshape(1,6)
print(c)
[[1 2 3]
[2 3 4]]
(2, 3)
1
[[1 2 3 2 3 4]]
# 更多创建二维数组的方法
a = np.ones((2,3),dtype='i1') # np.ones(shape,dtype=float) 表示生成shape形状的全是1的数组 如果不知道dtype 默认是float
a
array([[1, 1, 1],
[1, 1, 1]], dtype=int8)
a = np.zeros((3,2)) # np.zeros(shape,dtype=float) 表示生成shape形状的全是1的数组 如果不知道dtype 默认是float
a
array([[0., 0.],
[0., 0.],
[0., 0.]])
a = np.empty((2,3)) # np.empty(shape,dtype=float) 可以根据指定的形状和数据类型生成数组，其中的没有初始化
a
array([[0., 0., 0.],
[0., 0., 0.]])
a=np.full((2,3), 5) # np.full(shape, full_value, dtype=None) 可以根据指定的形状和数据类型进行填充数据
a
array([[5, 5, 5],
[5, 5, 5]])
# np.identity(n, dtype=None) 创建单位矩阵，对角线元素为1，其余元素为0
a = np.identity(2)
a
array([[1., 0.],
[0., 1.]])
# np.eye(N,M=None,k=0,dtype=float) 表示创建二维数组，对角线为1.0，其余为0.0， N表示行数，M表示列数，默认是N*N k是对角线的开始位置索引 默认是0
# 0表示主对角线
a = np.eye(3,4, k=2)
a
array([[0., 0., 1., 0.],
[0., 0., 0., 1.],
[0., 0., 0., 0.]])
# 数组的属性
# ndim 数组的维度
# shape 数组的形状 每个维度的元素个数
# size 数组元素的总个数
# litemsize 每个元素的大小 以字节为单位
# nbytes 数组的总字节数 以字节为单位
a = np.ones((2,3))
print(a)
print(a.ndim)
print(a.shape)
print(a.size)
print(a.itemsize)
print(a.nbytes)
print(a.dtype)
[[1. 1. 1.]
[1. 1. 1.]]
2
(2, 3)
6
8
48
float64
# 数组的轴
a = np.arange(1, 10, )
a
b = a.reshape([3,3])
b
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
b[1,2] # 等同于b[1][2]
b[1]
c = b[0] + b[1]
c
array([5, 7, 9])
# 数组转置
a = np.arange(0, 10)
b = a.reshape([2,5])
print(b)
b.T
c = np.reshape(b,[10,])
print(c)
[[0 1 2 3 4]
[5 6 7 8 9]]
[0 1 2 3 4 5 6 7 8 9]
# 数组转列表
x= b.tolist()
x
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
# 索引访问
b[1,2] # 等同于b[1][2]
b[-1]
array([5, 6, 7, 8, 9])
# 一维数组的切片
a[1:4]
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
# 二维数组的切片
a = np.arange(0, 10)
b = a.reshape((2,5))
b[:,:3]
# 可以将切片和索引一起使用
b[1,:]
array([5, 6, 7, 8, 9])
# 布尔索引 布尔索引的形状必须和索引素组形状相同 深层复制 不影响原数组
a = np.arange(0, 4)
b = np.array([False, True, False, True])
a[b]
[0 1 2 3]
array([1, 3])
# 花式索引 返回的新数组属于深层复制
a = np.arange(0, 10)[::-1]
print(a)
b = np.array([2,3,4])
c = [2,3,4]
print(a[b])
print(a[c])
d = np.array([[1,2],[2,3]])
print(a[d])
[9 8 7 6 5 4 3 2 1 0]
[7 6 5]
[7 6 5]
[[8 7]
[7 6]]
# 花式索引 返回的新数组属于深层复制
e = a.reshape((2,5))
print(e)
x = np.array([[1,0], [0,1]])
y = np.array([[2,3], [3,4]])
e[x,y]
e[x,2]
[[9 8 7 6 5]
[4 3 2 1 0]]
array([[2, 7],
[7, 2]])
# 迭代数组
# 通过nditerlei进行迭代
a = np.arange(0, 10).reshape((2,5))
for n in np.nditer(a):
print(n,end=',')
0,1,2,3,4,5,6,7,8,9,
# 数组操作
# concatenate函数沿指定的轴连接多个数组，除了指定轴以外 其他轴的元素个数必须相同
# np.concatenate((a1,a2...), axis=0)
a = np.arange(0,3, dtype='i1').reshape(3,1)
print(a)
b = np.arange(0,6, dtype='i1').reshape((2,3))
b.shape
print(b.T)
ab = np.concatenate((a,b.T),axis=1)
ab
[[0]
[1]
[2]]
[[0 3]
[1 4]
[2 5]]
array([[0, 0, 3],
[1, 1, 4],
[2, 2, 5]], dtype=int8)
# hstack沿水平方向堆叠多个数组 np.hstack(tup) tup表示多个要连接的元组
a = np.arange(0,2).reshape(2,1)
b = np.array([[1,2], [3,4]])
ab = np.hstack((a, b))
ab
array([[0, 1, 2],
[1, 3, 4]])
# vstack沿垂直方向堆叠多个数组 np.vstack(tup) tup表示多个要连接的元组
a = np.arange(0,2).reshape(1,2)
b = np.array([[2,3],[4,5]])
ab = np.vstack((a,b))
ab
array([[0, 1],
[2, 3],
[4, 5]])
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
[array([0, 1]), array([2, 3, 4, 5]), array([6, 7, 8])]
[[0 1 2]
[3 4 5]
[6 7 8]]
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
# hsplit vsplit分别表示水平方向和垂直方向进行分割
f = np.hsplit(d, 3)
f
g = np.vsplit(d, 3)
g
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
# 算术运算
a = np.arange(0,9).reshape((3,3))
print(a)
b = a + 10
print(b)
c = np.array([[12,3,4],[3,4,6],[4,3,1]])
d = a + c
d
[[0 1 2]
[3 4 5]
[6 7 8]]
[[10 11 12]
[13 14 15]
[16 17 18]]
array([[12, 4, 6],
[ 6, 8, 11],
[10, 10, 9]])
# 标量广播
# 不同形状的数组或标量计算时发生广播
a = np.arange(0,4).reshape(2,2)
b = a + 10
b
array([[10, 11],
[12, 13]])
# 数组广播
# 如果两个素组维度不相等，维度较低的数组的形状会从左侧开始填充1，直到维度和高维度数组相等
# 如果两个数组维度相等，要么对应轴的长度相同，要么其中一个长度为1，则是兼容数组可以广播，长度为1的轴会被扩展。
# 如果不满足上述两个条件 则会报错
a = np.arange(0, 2)
print(a)
print(b)
c = b + a
c
[0 1]
[[10 11]
[12 13]]
array([[10, 12],
[12, 14]])
# 通用函数
# 数学运算函数
a = np.arange(0,2)
print(a)
b = np.arange(3,5)
# c = np.ones((2,),dtype='i1')
c = np.add(a, b)
print(c)
[0 1]
[3 5]
# 关系运算函数
c = np.equal(a, b)
d = a<1
d
array([ True, False])
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
