Numpy
1.numpy简介
①Numpy是一个科学计算库，用于快速处理任意维度的数组
②支持常见的数组和矩阵操作
③有一个强大的数组ndarray
④广播功能函数
⑤线性代数、傅里叶变换、随机数生成等功能
2.ndarray简介
①提供了一个N维数组类型ndarray，描述了相同类型的数据的集合，以下标0开始进行集合中元素的索引
②ndarray对象用于存放同类型元素的多维数组
③ndarray中的每个元素在内存中都有相同大小的存储区域
④ndarray一般用于处于数字，很少用于处理字符串
import numpy as np
#array中存储一个列表，列表中有存放多个列表
score = np.array([[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99]])
#输出列表
print(score)
#比较使用nunpy与list效率的比较
import numpy as np
import random
import time
# 由于要生成随机数组和计时，因此我们导入random和time包
a = []
# 生成10000000个随机数放入数组
for i in range(10000000):
# 利用random.random()来生成随机数
a.append(random.random())
t1 = time.time()
sum_number = sum(a)
t2 = time.time()
print(sum_number)
nparray = np.array(a)
d1 = time.time()
sum_array = sum(nparray)
d2 = time.time()
print(t2 - t2)
print(d2 - d1)
print(sum_array)
2.ndarray的属性
| 属性 | 说明 |
|---|---|
| shape | 数组的维度，矩阵为n行m列 |
| dtype | 元素类型 |
| ndim | 数组维度又称数组的秩，几维数组秩就为几 |
| size | 数组中的元素数量，shape中n*m的值 |
| itemsize | 每个元素的大小，以字节为单位 |
| flags | 对象的内存信息 |
| real | 元素的实部 |
| imag | 元素的虚部 |
| data | 包含实际数组元素的缓冲区，由于一般通过数字的索引获取元素，所以通常不需要使用这个属性 |
import numpy as np
score = np.array([[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99],
[80, 79, 60, 98, 99]])
# 查看ndarray的形状
print(score.shape) # (8, 5)
# 查看ndarray的维度
print(score.ndim) # 2
# 查看ndarray的元素个数
print(score.size) # 40
# 查看ndarray的类型：在创建ndarray时没有主动指定类型，如果是数值型则为int32/64
print(score.dtype) # int32
1.shape–数组的形状
①几个维度：最简单的方法是看左侧有几个[
②每一个数字表示该维度的元素个数
import numpy as np
# 每一个数字表示该维度的元素个数
# 几个维度：最简单的方法是看左侧有几个[
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([1, 2, 3, 4])
c = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(a.shape) # (2, 3)
print(b.shape) # (4,)：维度为，1,因此用一个数字表示，元素个数为4，由于表示形式为元组，因此只有一个数字时要加一个逗号
print(c.shape) # (2, 2, 3):
③nparray三位数组结构：先看有几个数组，然后再看每个数组中有几个维度，最后看有几个元素
2.dtype–数组的类型
①在创建ndarray时没有主动指定类型，如果是数值型则为int32/64，浮点型为float32/64
②可以在创建数组时来指定类型
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]],dtype='float32')
b = np.array([1, 2, 3, 4],dtype=np.float32)
3.numpy的数据类型与设置
1.数据类型
①numpy支持的数据类型比python内置的要多，和c语言可以基本对应上。
②numpy的数值类型实际上是dtype对象的实例，并对应唯一的字符，如np.bool__等，如下所示
| 符号 | 说明 |
|---|---|
| bool_ | 布尔类型的数据(True或者False) |
| int_ | 默认的整数类型 |
| intc | 与C的int类型一样，一般是int32或int64 |
| intp | 用于索引的整数类型 |
| int8 | 字节(-128~127) |
| int16 | 整数(-32768~32767) |
| int32 | 整数(-2147483648~2147483647) |
| int64 | 整数(-8223372036854775808~9223372036854775807) |
| uint8 | 无符号整数(0~255) |
| uint16 | 无符号整数(0~65535) |
| uint32 | 无符号整数(0~4294967295) |
| uint64 | 无符号整数(0~18446744073709551615) |
| float_ | float64类型的简写 |
| float16 | 半精度浮点数，包括：1个符号位，5个指数为，10个尾数位 |
| float32 | 单精度浮点数，包括：1个符号位，8个指数为，23个尾数位 |
| float64 | 双精度浮点数，包括：1个符号位，11个指数为，52个尾数位 |
| float64complex_ | complex128类型的简写，即128位复数 |
| complex64 | 复数，表示双32位浮点数(实数部分和虚数部分) |
| complex128 | 复数，表示双64位浮点数(实数部分和虚数部分) |
每个内建类型都有一个唯一定义它的字符代码
| 字符代码 | 说明 |
|---|---|
| b | 布尔型 |
| i（1、2、4、8） | 有符号整型(1代表int8，2代表int16，4代表int32，8代表int64) |
| u | 无符号整型integer |
| f | 浮点型 |
| c | 复数浮点型 |
| m | timedalta时间间隔 |
| M | datatime日期时间 |
| O | python对象 |
| S,a | (byte)字符串 |
| U | Unicode |
| V | 原属数据(void) |
2.数据类型的设置
①字节顺序：<意味着小端法，最小值存储在最小的位置，即低位组放在最前面，默认；
>意味着大端法，最重要字节存储在最小的位置，即高位组放在最前面
#数据类型的设置
np.dtype(object,align,copy)
objcet：要转换位的数据类型对象，即从上面的数据类型中选取，写法np.数据类型或'字符代码'
align：如果设置为True，则填充字段使其类似C的结构体
copy：复制dtpye对象，如果为false，则是对内置数据类型对象的引用
#案例
np.dtype(np.int32)
np.dtype('<i4')
#结构化数据对象--变量名=np.dtype([('属性名1','属性类型1'),('属性名2','属性类型2'),('属性名3','属性类型3')])：相当于自己设置一个类型
student=np.dtype([('name','S20'),('age','y4'),('marks','f4')])
print(studnet) # [('name','S20'),('age','y4'),('marks','f4')]
4.创建ndarray数组对象
①numpy默认ndarray的所有元素的类型是相同的，如果传进来的列表中包含不同的类型，则统一位同一类型，优先级：str>float>int
1.np.array()
np.array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)
object：数组、嵌套的数列或已经创建好的数组
dtype：数组元素的数据类型，可选
copy：可选参数，对象是否需要复制，默认为True，拷贝成功后修改原数组不会对数组的值造成影响
order：船舰数组样式，C位行方向，F位列方向，A位任意方向(默认)
subok：默认返回一个与基类类型一致的数组
ndmin：指定生成数组的最小维度
#使用
# 1.创建一维数组
arr = np.array([1,2,3,4,5,6])
# 2.创建元素类型要相同，如果不同怎会按照str>float>int的优先级进行转换
arr = np.array([1,2,3,4,5,6.0] # [1.,2.,3.,4.,5.,6.]
# 3.创建多维数组
arr = np.array([[1,2,3],[4,5,6]])
[[1 2 3]
[4,5,6]]
# 4.设置ndmin：规定最小维度，如下下面的数组是一维的但是规定最下为二维，那就创建了一个含有一个元素的二维数组
arr = np.array([1,2,3,4,5,6],ndmin=2)
[[1,2,3,4,5,6]]
# 5.设置dtype:虽然写的是整数但是由于设置了dtye=np.float,因此元素全部换为浮点数
arr = np.array([1,2,3,4,5,6],dtype=np.float,ndmin=2)
可以用简写
arr = np.array([1,2,3,4,5,6],dtype='f',ndmin=2)
[[1.,2.,3.,4.,5.,6.]]
# 6.结构化类型：创建一个自定义类型，并使用array添加元素
student=np.dtype([('name','S20'),('age','i4')])
arr = np.array([('Tom',18),('Lili',20)],dtype=student)
2.np.asarray()
np.asarray(a,dtype=None,order=None)
a：任意形式的输出参数，可以是列表、列表的元组、元组、元组的元组、元组的列表、多维数组
dtype：数组元素的数据类型，可选
order：创建数组样式，C位行方向，F位列方向，A位任意方向(默认)
#使用
# 1.创建一维数组，参数是列表
arr = np.asarray([1,2,3,4,5,6])
# 2.创建一维数组，参数是元组
arr = np.asarray((1,2,3,4,5,6))
# 3.创建二维数组
arr = np.asarray([(1,2,3),(4,5)])
[(1,2,3),(4,5)]一维，shepe=(2,)
# 4.dtype
arr = np.asarray([1, 2, 3, 4, 5, 6], dtype='i4')
3.np.empyt()
#创建一个形状维shape，类型为dtype的未初始化的数组
np.empyt(shape,dtype=float,order='C')
shape：数组形状,可以是元组()或列表[]的形式
dtype：数据类型
order：创建数组样式，C位行方向，F位列方向，A位任意方向(默认)
# 创建数组：里面的值每次都不一样，不确定
arr = np.empty((3, 2), dtype=int)
4.np.zeros() 与np.ones()
# 生成一组0
np.zeros(shape=(a,b),dtype='类型',order='C')
# 生成一组1
np.ones(shape=(a,b),dtype='类型',order='C')
shape：数组形状,可以是元组()或列表[]的形式
dtype：数据类型
order：创建数组样式，C位行方向，F位列方向，A位任意方向(默认)
# 创建全为0的一维数组
arr = np.zeros((5,), dtype=int)
# 创建全为1的二维数组
arr = np.ones(shape=(2, 3),dtype=int)
5.np.copy()
①np.array()与np.asarray()为浅拷贝，即便是生成后元素组再被修改，该数组的相应元素也会修改；copy为深拷贝，该数组的相应元素不会被修改
②复制出来的新数组按什么方式进行复制，F按原来数组列序来进行存储生成新的数组，C按原来数组行序来进行存储生成新的数组
③只有array与asarray、转置、ravel、transpose暂且认为是浅拷贝，其他的拷贝都是深拷贝
np.copy(arr,order='F')
order='F':列序存储,order='C'：行序存储
6.np.full()
# 创建
np.full(shape,fill_value,dtype=None,order='C')
np.ones(shape=(a,b),dtype='类型',order='C')
shape：数组形状,可以是元组()或列表[]的形式
fill_value：填充的数据
dtype：数据类型
order：创建数组样式，C位行方向，F位列方向，A位任意方向(默认)
#案例
arr = np.full((2, 2), fill_value=100, dtype=int)
7.np.eye()
# 创建对角线元素都为1的数组
np.eye(N,M=None,k=0,dtype=float,order='C')
N：行的数量
M：列的数量，默认等于行的数量，可选
dtype：数据类型
order：创建数组样式，C位行方向，F位列方向，A位任意方向(默认)
# 案例
arr = np.eye(10,5, dtype=int)
[[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 0 0 0 0]
[0 0 0 0 0]
[0 0 0 0 0]
[0 0 0 0 0]
[0 0 0 0 0]]
arr = np.eye(10, dtype=int)
[[1 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 1]]
8.np.arange()
# 创建数值范围并返回ndarray对象，根据start与stop指定的范围以及step设定的步长生成一个ndarray数组
np.arange(start,stop,step,dtype)
start：起始值，默认为0
stop：终止值(不包含)
step：步长，默认为1
arr = np.arange(1, 11, 1, np.float)
9.np.frombuffer()
# 用于实现动态数组，接收buffer输入参数，以流的形式读入转化成ndarray对象。
np.frombuffer(buffer,dtype=float,count=-1,offset=0)
buffer：可以是任意对象，会以流的实行读入
dtype：数据类型
count：读取的数据数量，默认为-1，读取所有数据，如果设置了其他值则只会取字符串中的count个元素
offset：读取的其实位置，默认为0，从offset下标出开始那
# buffer是字符串的时候，python3默认是unicode类型，因此要转成byetstring在原str前加上b
# 从下标为2处开始拿，拿5个，包含空格
str = b'123bvagb'
arr = np.frombuffer(str, dtype='S1',count=5,offset=2)
10.np.fromiter()
# 从可迭代对象中创建ndarray对象，返回一维数组
np.fromiter(iterable,dtype,count)
iterable：可迭代对象
dtype：数据类型
count：读取的数据量，默认为-1，读取所有数据
a = [1, 2, 3, 4, 5]
# iter()函数用来生成迭代器。
z = iter(a)
arr = np.fromiter(z, dtype=np.float)
11.np.linspace()
# 创建等差数列，生成固定范围的数组,生成从min到max(都可以取到)等距离的count个元素
np.linspace(min,max,count,endpoint=True,retstep=False,dtype=None)
min、max：最小最大范围
count：生成元素的个数，默认为50
endpoint：该值为True时，包含最大值，默认为True
retstep：如果为True，生成的数组会显示间距
dtype：数据类型
arr = np.linspace(1, 10, 5, retstep=True)
# (array([ 1. , 3.25, 5.5 , 7.75, 10. ]), 2.25)
12.np.logspace()
# 创建等比数列，生成固定范围的数组,生成从min到max(都可以取到)等距离的count个元素
np.logspace(min,max,count,endpoint=True,base=10.0,dtype=None)
min、max：最小最大范围
count：生成元素的个数，默认为50
endpoint：该值为True时，包含最大值，默认为True
base：对log的底数，默认是10
dtype：数据类型
arr = np.logspace(1, 10, 5)
# [1.00000000e+01 1.77827941e+03 3.16227766e+05 5.62341325e+07 1.00000000e+10]
13.产生随机数
1.np.random.rand()–float类型
# 生成一个0到1之间的随机数(包含0不包含1)，float类型
np.random.rand()
# 生成一个0到1之间的含有size个元素的一维数组
np.random.rang(size)
# 生成一个0到1之间的含有size1行size2列的二维数组
np.random.rang(size行，size列)
# 生成一个0到1之间的shapesize1,size2,size3的三维数组
np.random.rang(size1，size2，size3)
arr = np.random.rang(3,2,2)
2.np.random.random()–float类型
# 生成一个0到1之间的随机数(包含0不包含1)，float类型
np.random.random()
# 生成一个0到1之间的含有size个元素的一维数组
np.random.random(size)
#不可以传两个参数只可以传一个参数表示个数
arr = np.random.random(3)
3.np.random.randint()–int类型
# 生成一个0到1之间的整数
np.random.randint(min,max,size,dtype)
min、max：左闭右开
size：元素个数
dtype：元素类型
# 生成10个1到10之间一维数组
arr = np.random.randint(1,10,10)
4.np.random.uniform()–均匀分布
①均匀分布：表示每一个的可能性时相等的
# 均匀分布，生成从low到high之间size个随机数，size也可以传递一个shape，入size=(8,10)8行10列共80个数
np.random.uniform(low=-1, high=1, size/shape=100000)：
import numpy as np
import matplotlib.pyplot as plt
# 均匀分布：表示每一个的可能性时相等的
# np.random.uniform(low=-1, high=1, size=100000)：均匀分布，生成从low到high之间size个随机数
data1 = np.random.uniform(low=-1, high=1, size=100000)
print(data1)
# 利用到matplotlib生成一个直方图
# 创建画布
plt.figure(figsize=(20,8),dpi=80)
# 绘制直方图
plt.hist(data1,1000)
# 显示图像
plt.show()
5.np.random.normal(loc,scale,size/shape)–正态分布
①正态分布是具有两个参数μ和o（cgema）的连续随机变量分布，μ是服从正态分布的随机变量的均值，σ是此随机变量的方差，因此正态分布记作N（μ，σ）。方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，可以理解为幅度、波动程度、集中程度、稳定性、离散程度的意思。方差越小越稳定，所有的数据相同时方差为0（因为数据和该数据的平均数一样，相减为0），最稳定
②u在坐标轴上表示该图形以谁做对称轴，方差越大图像越低(扁)，即数据更加分散
np.random.normal(loc,scale,size/shape)
loc表示均值
scale表示标准差
size为形状(数值个数)
arr = np.random.normal(0, 1, (2, 2))
# 案例
import numpy as np
import matplotlib.pyplot as plt
# np.random.normal(loc=,scale=,size=)：loc表示均值，scale表示标准差，size为形状(数值个数)
data = np.random.normal(loc=1.75, scale=0.1, size=1000)
print(data)
#也可以使用matpotlib生成直方图
plt.figure(figsize=(4, 5), dpi=60)
plt.hist(data, 100)
plt.show()
④方差
其中M为这组数据的平均数，s为标标准差，s的平方为一个整体即方差
⑤标准差
⑤正态分布特点
5.元素的操作
1.ndarray的索引、切片操作
①数组的切片、索引操作(下标从0开始)
②一维数组的操作：如果只放置一个参数，如[2]，将返回与该索引相对应的单个元素；如果为[2:]，表示从该索引开始以后的所有项都被提取；如果使用了两个参数，如[2:7]，那么则提取两个索引之间的项
arr = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
# 索引的方式
arr[1] # 1
# 切片冒号的方式：获取下标0到6的元素，没三个才取
arr[0:7:3] # [0 3 6]
arr[2:] # [2 3 4 5 6 7 8 9]
# 切片slice的方式：获取下标0到6的元素，没三个才取
s = slice(0, 7, 3)
arr[s] # [0 3 6]
# 一维数组获取数据及修改：将2修改为3
num = np.array([1, 2, 3, 4, 5, 6])
num[1] = 3
num[2,7,2]
②多维数组的操作
arr = np.arange(15)
arr.shape = (5, 3)
print(arr)
# 一个索引：arr[index],表示从下标开始第index行
arr[2] # 第3行 [6 7 8]
# arr[start:end]：从start到end
arr[2:] # 从第二行开始到结束
# 两个索引：arr[index1][index2]表示下标从0开始的第index1行第index2列
# 也可以写在一个[]中用逗号隔开
arr[2][1] # 7
arr[2, 1] # 7
arr[2:, 1:3] # 第二行到结束的行，每行的索引为1到2的列
arr[2:,[1,3]] # 第二行以后，且纵坐标索引为1和3的元素
# 三维数组获取数据及修改：获取9，获取5，6，将2，3修改为22，33
a = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
a[1, 0, 2]
a[0, 1, 1:3]
a[0:3,1:2,1:3]
a[0, 0, 1:3] = [22, 33]
a[0:2,[1,3],1:]
③切片还可以包括省略号 … 来使选择元组的长度与数组的维度相同。如果在行的位置使用省却好，他将返回包含行中元素的ndarray
arr = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]])
# 本例中...相当于5，但是写5会报错指针超出范围，只有写...会认为他是维度5，数组5则会被认为是下标索引
# 第二列元素
arr[..., 1]
# 第二行元素
arr[1, ...]
# 第二列及剩下的所有元素
arr[..., 1:]
# 三位数组也是一样，按照索引一维一维的获取即可
a = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(a[..., 1, 2]) # [ 6 12]
2.高级索引
1.整数数组索引
#每个列表里放一个维度
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 获取索引为 (0,0) (1,1) (2,0)即1,5,7
# arr[],[]中分别写两个或多个列表，一个列表用于写所有点的第一维坐标(二维中为横坐标),一个用于写所有点的第二维坐标(二维中为纵坐标)，如果是三维坐标写第三维点的列表即可
arr[[0, 1, 2], [0, 1, 0]]
# 三维数组中获取(0,3,1),(1,1,2),(2,2,3)三个点的元素
arr[[0,1,2],[3,1,2],[1,2,3]]
#行索引与列索引纵向拼接
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
# 行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2]
# 获取行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2],首先写出行与列两个数组把题目中的坐标写入,然后竖着拼接，拼出来的(0,0),(0,2),(3,0),(3,2)既是对应元素的坐标
row = np.array([[0, 0], [3, 3]])
cols = np.array([[0, 2], [0, 2]])
print(arr[row, cols])
[[1 3]
[10 12]]
#借助切片：或...与索引数组组合
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
arr[1:3, 1:3]
5 6
8 9
#那1到2行，然后获取这样两中索引为1和索引为2的元素
arr[1:3, [0, 2]]
[[4 6]
[7 9]]
arr[..., 1:]
2 3
5 6
8 9
11 12
2.布尔索引
①通过布尔运算来获取符合指定条件的元素的数组，返回一个一维数组
# 返回满足数组元素大于5的的元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
arr[arr > 5]
[ 6 7 8 9 10 11 12]
# 过滤nan：isnan表示是nan的元素，前面加上~表示取反即不是nan的元素
arr = np.array([np.nan, 1, 2, np.nan, 4, 5, 6])
arr[~np.isnan(arr)]
[1. 2. 4. 5. 6.]
6.迭代
1.np.nditer()–迭代
①它是一个有效的多维迭代对象，可以用在数组上进行迭代。数组的每个元素科使用Python的标准Iterator接口来访问
np.nditer(arr,order,op_flags,flags)
order：order='F'：列序优先，order='C'：行序优先
op_flags：不设置改制默认为只读（只可以读取arr中的数据不可以修改），如果将他设置为op_flags=['readwrite']则可读可写
flags：c_index--可以跟踪C顺序的索引
f_index--可以跟踪Fortran顺序的索引
multi-index--每次迭代可以跟踪一种索引类型
external_loop--给出的值具有多个值的一维数组，而不是零为数组
②顺序选择和数组内布局一致，默认行优先
arr = np.arange(12)
arr = arr.reshape(3, 4)
for x in np.nditer(arr):
print(x, end='')
#01234567891011
③定义好了一个数组a，a与a.T的遍历顺序是一样的，因为转置没有改变原数组，但是使用a.T.copy(order=‘c’)则遍历结果就改变了，因为copy是深拷贝，会重新将数组进行存储
arr = np.arange(12)
arr = arr.reshape(3, 4)
for x in np.nditer(arr):
print(x, end='')
#01234567891011
for x in np.nditer(arr.T):
print(x, end='')
#01234567891011
for x in np.nditer(arr.T.copy()):
print(x, end='')
#04815926103711
④控制遍历顺序
arr = np.arange(12)
arr = arr.reshape(3, 4)
b = arr.T #仍为行序存储123456...
c = np.copy(b, order='C')#copy改变了存储的方式改为了列序0 4 8...，然后再根据order进行存储进行行序存储，因此0,4,8...的行序为0 4 8...
a,b [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
c [[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
for x in np.nditer(c):
print(x, end='')
#04815926103711
#对数组进行修改
arr = np.arange(12)
arr = arr.reshape(3, 4)
for x in np.nditer(arr, op_flags=['readwrite']):
x[...] = x * 2
print(arr)
[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]]
⑤外部循环
flags：c_index--可以跟踪C顺序的索引
f_index--可以跟踪Fortran顺序的索引
multi-index--每次迭代可以跟踪一种索引类型
external_loop--给出的值具有多个值的一维数组，而不是零为数组
for x in np.nditer(arr, flags=['c_index'], order='F'):
print(x)
⑥广播迭代：如果两个数组是可广播的，nditer组合对象能够通过迭代他们，数组arr2被广播到arr1的大小，即长的数组循环不结束短的数组会一直跟着循环
注意：前提可广播
arr1 = np.arange(12).reshape(3, 4)
arr2 = np.arange(1, 5)
for x, y in np.nditer([arr1, arr2]):
print('%d:%d' % (x, y), end=' ')
# 数组arr2被广播到arr1的大小，arr1不结束循环，arr2的元素就会继续和arr1的元素拼凑循环。即长的数组循环不结束短的数组会一直跟着循环
# 0:1 1:2 2:3 3:4 4:1 5:2 6:3 7:4 8:1 9:2 10:3 11:4
2.arr.flat–数组元素迭代器
数组元素迭代器flat
arr--123456
for x in arr.flat:
print(x)
1
2
3
4
5
7.数组形状修改
①方式一、方式二仅会改变形状不会对行列进行转换：数组只是修改了形状,将数据按顺序重新分组并未修改顺序，如(2,3)的[1,2,3],[4,5,6]改为(3,2)的[1,2],[3,4],[5,6]
1.arr.reshape()
# 方法一：数据变量.reshape(shape,order='C/F')：返回新的数组，并不会对原来的数组进行修改，shape参数可以写一个另一个写-1，即为自动计算，C行F列
new_stock_data = stock_data.reshape((10, 8))
new_stock_data = stock_data.reshape((-1, 8))
2.arr.resize()
# 方法二：np.resize(arr,shape)：对原有的数组进行修改，没有返回值,个reshape一样，只改变形状不会对行列的值进行转换，如果改变后的形状所需要的元素多余之前的，会从第一个元素往后拿补充到剩余位置
np.resize(arr,(10, 8))
3.arr.T–转置
# 方式三：数据变量.T()：数组的转置,返回新的数组
new_stock_data = stock_data.T
# 多维度矩阵转置：(2,4,3)矩阵进行转置则会将维列互换，即(3,4,2)：先将数组写出来，从第一个元素竖这将不同维度对应位置的数组合
a = np.array(
[[[1, 2, 3], [13, 14, 15], [4, 5, 6], [24, 25, 26]], [[7, 8, 9], [10, 11, 12], [17, 16, 18], [34, 35, 63]]])
b = a.T
[[[1,7],[13,10],[4,17],[24,34]] , [[2,8],[14,11],[5,16],[25,35]] , [[3,9],[15,12],[6,18],[26,63]]]
4.arr.shape()
# 方式四：直接修改--数据变量.shape=shape
arr.shape=(3.2)
5.np.ravel()–展平
#方式五：np.ravel(order='C/F')：与flatten效果一样展平元素，返回视图,使用C浅拷贝，使用F深拷贝
a = np.array([[1, 2, 3, 4], [5, 2, 2, 4],[5, 2, 2, 4]])
b=a.ravel() #修改b后a也会改变
[1 2 3 4 5 2 2 4 5 2 2 4]
6.np.transpose()
①对换数组维度，浅拷贝
np.transpose(a,axes)
a:要操作的数组
axes:整数列表，对应维度，通常所有维度都会兑换
arr = np.arange(12).reshape(3, 4)
#二维数组列数变行数，行数编列数，且元素也跟着翻转
b = np.transpose(arr)
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
shape(4,3)
7.np.rollaxis()
#向后滚动特定的轴到一个特定位置
np.rollaxis(a,axix,start=0)
a:要操作的数组
axis:哪个轴滚
start:滚到哪个位置，默认为0，轴的下标按shape从前往后的顺序从0开始计算
arr = np.arange(60).reshape(3, 4, 5)
print(arr.shape)
b = np.rollaxis(arr, 2, start=1)
print(b.shape)
(3, 4, 5)
(3, 5, 4)
8.np.swapaxes()
# 交换axis1与axis2两个轴
np.swapaxes(a,axis1,axis2)
a:要操作的数组
axis:哪个轴滚
arr.shape=(2,3,4)
arr = np.swapaxex(arr,1,2)
# shape=(2,4,3)
8.修改数组维度（不常用）
1.np.broadcast()
①用于模仿广播的对象，他返回一个对象，该对象封装了将一个数组广播到另一个数组的结果
np.broadcast()
x = np.array([[1], [2], [4]])
y = np.array([4, 5, 6])
b = np.broadcast(x, y)
r, c = b.iters
while True:
print(next(r),next(c))
if not r and not c:
break
2.np.broadcast_to()
①将数组广播到新形状，在原始得到数组上返回一个只读的视图，他通常不连续。
②修改前与修改后数组的形状要满足广播规则，如果形状不符合广播规则，该函数可能会抛出ValueError
np.broadcast_to(array,shape,subok=False)
array:待修改的数组
shape:修改后的形状
arr = np.arange(1, 5).reshape(1, 4)
b = np.broadcast_to(arr, (4, 4))
print(b)
[[1 2 3 4]
[1 2 3 4]
[1 2 3 4]
[1 2 3 4]]
3.expand_dims()
# 给arr添加一个axis轴
np.expand_dims(arr,axis)
axis:新轴插入的位置从0开始
arr = np.arange(1, 5).reshape(2, 2)
print(arr)
# 变成了含有一个元素的三维数组，这个元素为二维数组
arr1 = np.expand_dims(arr, axis=0)
print(arr1)
[[[1 2]
[3 4]]]
（2，2）--[[1,2],[3,4]]
在0轴增加--在最外层添加一个[]，即（1,2,2）[[[1,2],[3,4]]]
在1轴增加--给次外层每个元素添加一个[]，即（2,1,2）[[[1,2]],[[3,4]]]
4.np.squeeze()
# 给定的数组形状中删除一维的条目
np.squeeze(arr,axis=0)
axis:删除的轴，会自动删除size为1的哪个轴，没有则不会改变，即去掉最外层的括号或最外层每个元素的括号，如果删除后结果不成样子则数组会保持不变，不会继续删除。
arr = np.arange(1, 10).reshape(1, 3, 3)
arr1 = np.squeeze(arr)
[[1 2 3]
[4 5 6]
[7 8 9]]
9.数组的去重
1.np.unique(arr)
①数组的去重：之前可以将其转换为set()，因为集合中不会有重复元素，但是numpy数组是不可以转换成set，只有一维的可以使用set进行转换，因此多维的数组需要使用unique方法
②np.unique(数据变量)：去掉数组中重复的元素，并将不重复的元素作为一个新的ndarray数组返回
# 去掉数组中重复的元素，并将不重复的元素作为一个新的ndarray数组返回
np.unique(arr,return_index,return_inverse,return_counts)
return_index:如果为True，返回新列表元素在旧列表中的索引位置，并以列表形式按顺序存储（新数据元素对应在旧数组中的下标）
return_inverse:如果为True，返回旧列表元素在新列表中的索引位置，并以列表形式按顺序存储（旧数据元素对应在新数组中的下标,个数比新数组多，因为是去重之前的。
return_counts:如果为True，返回去重数组中的元素在原数组中出现的次数，并以列表形式按顺序存储
a = np.array([[1, 2, 3, 4], [5, 2, 2, 4]])
a = np.unique(a)
print(a) # [1 2 3 4 5]
print(a.shape)(5, )
2.flatten()+set()
③多维数组使用set来去重需要先用flatten转换为一位数组，然后再用set转换为集合
#将数组变成一维的，有返回值，原数组不会造成影响
数据变量.flatten(order='C/F/A/K')
C:按行
F:按列
A:按原序
k:元素在内存中出现的顺序
#按列
a = np.array([[1, 2, 3, 4], [5, 2, 2, 4]])
print(a.flatten(order='F'))
[1 5 2 2 3 2 4 4]
#默认按行
a = np.array([[1, 2, 3, 4], [5, 2, 2, 4]])
print(a.flatten())
[1 2 3 4 5 2 2 4]
#去重
import numpy as np
a = np.array([[1, 2, 3, 4], [5, 2, 2, 4]])
# 数据变量.flatten()：将数组变成一维的，有返回值，原数组不会造成影响
a = a.flatten() # [1 2 3 4 5 2 2 4]
# 将a转换为set去重
a = set(a)
print(a)
10.连接数组（不常用，记住第一个即可）
1.np.concatenate()
#用于沿指定轴连接相同形状的两个或多个数组,形状对应维度相加
np.concatenate((a1,a2,...),axis)
(a1,a2,...)：相同类型的数组
axis：按哪个轴连接，默认为0行拼，1列拼
rr1 = np.arange(4).reshape(2, 2)
arr2 = np.arange(4, 8).reshape(2, 2)
# 按0轴拼接，往下拼接(按行拼接)
arr3 = np.concatenate((arr1, arr2))
#按1轴拼接，往右拼接(按列拼接)
arr4 = np.concatenate((arr1, arr2), axis=1)
arr1 = np.arange(4).reshape(1, 2, 2)
arr2 = np.arange(4, 8).reshape(1, 2, 2)
# 按0轴拼接，第一维数相加(1, 2, 2)+(1, 2, 2)=(2, 2, 2)
arr3 = np.concatenate((arr1, arr2))
# 按1轴拼接，第二维数相加(1, 2, 2)+(1, 2, 2)=(1, 4, 2)
arr4 = np.concatenate((arr1, arr2), axis=1)
# 按2轴拼接，第三维数相加(1, 2, 2)+(1, 2, 2)=(1, 2, 4)
arr5 = np.concatenate((arr1, arr2), axis=2)
2.np.stack()–不常用
# 用于沿新轴连接数组序列
np.stack(arrays,axis)
arrays：相同形状的数组序列
axis：数组中的轴，输入数组沿着它来堆叠
arr1 = np.arange(1, 5).reshape(2, 2)
arr2 = np.arange(4, 8).reshape(2, 2)
# [[1,2],[3,4]]+[[4,5],[6,7]]=[ [[1,2],[3,4]]+[[4,5],[6,7]] ]给前面的整体加了个[]
arr3 = np.stack((arr1, arr2))
# [[1,2],[3,4]]+[[4,5],[6,7]]=[ [[1,2],[4,5]]+[[3,4],[6,7]] ]每个组对应位置元素在一起，然后整体加[]
arr4 = np.stack((arr1, arr2), axis=1)
arr1 = np.arange(4).reshape(1, 2, 2)
arr2 = np.arange(4, 8).reshape(1, 2, 2)
# 给前面的整体加了个[]
arr3 = np.stack((arr1, arr2))
# 每个组对应位置元素在一起，然后整体加[]
arr4 = np.stack((arr1, arr2), axis=1)
# 每个组对应位置元素在一起，然后整体加[]
arr5 = np.stack((arr1, arr2), axis=2)
3.np.hstack()、np.vstack()
# stack的变体，通过水平堆叠来生成数组
np.hstack():二维数组拼接时与concatenate()的列拼一样
np.vstack():二维数组拼接时与concatenate()的行拼一样
11.分割数组
1.np.split()
np.split(arr, groupcount,axis=0/1)：将arr进行分割，分成groupcount组，使用此方法进行分割时必须保证等份分割
np.split(arr, [分割点index1,分割点index2,分割点index3...],axis=0/1)：将arr进行分割，从分割index之前开始分割，参数二为存放分割点下标的列表
axis=0按行切，1按列切(刀竖着拿着切)
# np.split(arr, groupcount)：将arr进行分割，分成groupcount组，使用此方法进行分割时必须保证等份分割
arr = np.arange(9) # [0 1 2 3 4 5 6 7 8]
result = np.split(arr, 3)
# [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
# np.split(arr, [分割点index1,分割点index2,分割点index3...])：将arr进行分割，从分割index之前开始分割，参数二为存放分割点下标的列表
arr = np.arange(2, 9)
result = np.split(arr, [3, 4, 6, 10])
print(result)
12.数组元素的添加和删除
1.np.append()
# 在数组的末尾添加至，追加操作会分配整个数组，并把原来的数组复制到新的数组中，输入数组的维度必须匹配否则将报错
np.append(arr,values,axis=None)
value:向arr中添加的值，需要和arr形状相同(除了要添加的轴)
axis：当axis无定义时，是横向加成，返回总是为一维数组，axis=0，数组加在下面，列要相同；axis=1，数组加在右边，行要相同
arr = np.arange(6).reshape(2, 3)
# 不设置axis的值：直接按一维数组的形式加在后面
a = np.append(arr, [7, 8, 9])
# axix=0：加在原来数组的下面，因此维度必须是2维且列相同，行不一定要一样
b = np.append(arr, [[7, 8, 9]], axis=0)
b = np.append(arr, [[7, 8, 9], [10, 11, 12]], axis=0)
# axis=1：加在原有数组的右侧，因此维度必须要相同(2维)，行要一样
c = np.append(arr, [[7], [8]], axis=1)
[0 1 2 3 4 5 7 8 9]
[[ 0 1 2]
[ 3 4 5]
[ 7 8 9]
[10 11 12]]
[[0 1 2 7 8]
[3 4 5 8 9]]
2.np.insert()
①如果值的类型转换为要插入，则它与输入数组不同。插入没有原地的，函数会返回一个新数组。如果未提供轴，则输入数组会被展开
# 在给定索引之前，沿给定轴在输入数组中插入值
np.insert(arr,index,values,axis)
index:在哪个索引前插入
values:插入的值
axis:沿哪个轴插入，未提供，数组则会被展开
arr = np.arange(6).reshape(3, 2)
print(arr)
# 不设置axis：直接在索引之前插入元素，会返回一维数组
a = np.insert(arr, 3, [11, 12])
# [ 0 1 2 11 12 3 4 5]
# axis=0：在原有数组的下方进行添加，注意此时对应维度的元素数量要和原数组对应维度元素数量一样，如果不一样则添加的内容只可以是比原来数组的元素少且必须仅添加一个元素
b = np.insert(arr, 3, [11], axis=0)
b = np.insert(arr, 3, [11,12], axis=0)
[[ 0 1]
[ 2 3]
[ 4 5]
[11 12]]
# axis=1：在原有数组的右侧进行添加，注意此时对应维度的元素数量要和原数组对应维度元素数量一样，如果不一样则添加的内容只可以是比原来数组的元素少且必须仅添加一个元素
c = np.insert(arr, 1, [[11], [12,12], [13]], axis=1)
[[ 0 11 12 13 1]
[ 2 11 12 13 3]
[ 4 11 12 13 5]]
c = np.insert(arr, 1, 11, axis=1)
[[ 0 11 1]
[ 2 11 3]
[ 4 11 5]]
3.np.delete()
# 返回从输入数组中删除指定子数组的新数组。与insert()函数的情况一样，如果未提供轴参数，则会将数组展开
np.delete(arr,obj,axis)
obj:可以被切片，整数或者整数数组，表名要从输入数组删除的子数组
axis:沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
arr = np.arange(2, 14).reshape(3, 4)
# [ 2 3 4 5 7 8 9 10 11 12 13]
# 删除了索引为4的元素6
x = np.delete(arr, 4)
# axis=0：删除某一行
c = np.delete(arr, 1, axis=0)
# axis=1：删除某一列
b = np.delete(arr, 1, axis = 1)
# 删除了下标为1的那一整列
# [[ 2 4 5]
# [ 6 8 9]
# [10 12 13]]
13.ndarray运算
1.逻辑运算
①如果想要操作符合某一条件的数据时，应该用逻辑运算
1.对每一个元素进行判断
①data表示数组中的每一个元素，使用data可以对数组中的每一个元素进行逻辑判断，并且可以将该逻辑表达式作为标记写入[]来进行批量更改
import numpy as np
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# 对数组中的每一个元素进行操作，如数据变量>n:数组中的每个元素>n返回True，否则返回False，将这些True和False存入一个数组中返回
a = data > 0.5 # a的类型为ndarray
# 数据变量[条件表达式/条件比表达式返回值变量]=n：将数组中满足条件的元素改为n或其他操作
data[a] = 1.1 # 或data[data>0.5]=1.1
data[data - 0.5 > 0] = 1 # 每个元素-0.5如果大于0则将该元素设置为1
2.通用判断函数
1.np.all(布尔值)
①布尔值参数中只要有一个False就返回False，全是True则返回True
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# 判断数据是否全是正数
print(np.all(data > 0)) # False
2.np.any(布尔值)
①布尔值中只要有一个True则返回True，全是False则返回False
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# 判断前五行是否有整数
print(np.any(data[:5, :] > 0)) # 因为是8行10列的二维数组，所以第一个参数0:5表示1到5行，:表示0：11即全部列
3.三元运算符–np.where
①np.where(条件，value1/操作1，value2/操作2)：对元素进行判断，如果满足条件，则将其值置为valu1，如果不满足条件则将其值置为value2
②如果条件是一个符合的逻辑判断，如大于0并且小于1，或大于1或小于0等用到与和或，需要使用
np.logical_and–与
np,logical_or–或
np.logical_not–非
np.logical_xor–异或
③np.where(np.logical_and(data>0.5,data<1),1,0)
import numpy as np
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# 前4行前前四列的数如果大于0置为1，否则置为2
data = np.where(data[0:4, 0:4] > 0, 1, 2)
# 前4行前前四列的数如果大于0置为对应元素+1，否则置为对应元素+10
data = np.where(data[0:4, 0:4] > 0, data[0:4, 0:4] + 1, data[0:4, 0:4] + 10)
# 前4行前前四列的数如果大于0并且小于1的元素置为对应元素+1，否则置为对应元素+10
data = np.where(np.logical_and(data[:4, :4] > 0, data[:4, :4] < 1), data[0:4, 0:4] + 1, data[0:4, 0:4] + 10)
# 可以先将前四行前四列的数据取出来，在where中直接中
temp = data[0:4, 0:4]
data = np.where(np.logical_and(temp > 0, temp < 1), data[0:4, 0:4] + 1, data[0:4, 0:4] + 10)
2.统计运算
1.统计指标函数
①min、max、median(中位数)、var（方差）、std（标准差）、mean（平均值）
std=sqrt(mean(arr-arr.mean())**2)
②使用方式
np.函数名(数据变量,axis=0/1)：其中min、max、mean、median可以设置asix，当axis为0或-2是表示求每列的最大值，为1或-1表示求每行的最大值,不同的版本或库不一样，用的时候可以先试一下
#案例：
import numpy as np
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# 求前四行四列中最大的
temp = data[0:4, 0:4]
print(np.max(temp)) # 1.80911462161872
# 求前四行四列中某一行的最大值
print(np.max(temp, axis=1)) # [0.91864224 1.66607471 1.21918327 1.80911462]
2.最大值、最小值所在位置
①np.argmax(data,axis)：返回最大值所在的位置
②np.argmin(data,axis)：返回最小值所在位置
import numpy as np
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# np.argmax(data,axis)：返回最大值所在的位置
print(np.argmax(temp, axis=1)) # [3 0 2 3]
# np.argmin(data.axis)：返回最小值所在位置
print(np.argmin(temp, axis=-1)) # [0 3 1 0]
3.np.extract()
# 根据某个条件从数组中抽取元素，返回满足条件的元素
tiaojian=np.mod(x,2)==0 # x中的元素模余2等于0，返回True与False的集合
np.extract(arr,tiaojian)
4.ptp()
# 计算数组中元素最大值与最小值的差,设置axis时会返回一个数组返回每一行或每一列最大值与最小值的差
np.ptp(x,axis=0/1)
5.percentile()
# 百分位数是统计中使用的度量，表示小于这个值的观察值的百分比
np.percentile(arr,p,axis=0/1)
p；要计算的百分数，在0~100之间。第p个百分位数是这样一个值，它使得至少有p%的数据项小于或等于这个值，且至少有(100-p)%的数据项大于或等于这个值
x=np.array([[10,7,4],[3,2,1]])
np.percentile(x,50,axis=0)
6.average()
# 计算加权平均值，根据另一个数组给出的权重来计算，可以接收一个轴参数，入股没有指定，则数组会被展开
加权平均值：每个数值*权重相加求和，再除以总单位数(权重的和)
np.average(arr,axis=0(列)1(行),weight=quan,returned)
returned：将此参数设置为True则返回权重的和
# 不加权平均值
np.average(x)
# 加权平均值,y处也可以直接写一个列表
np.average(x,weights=y)
3.数学函数
1.三角函数
np.sin(角度*3.14/180)、cos()、tan()
#求a数组中各个角度的三角函数值
a=np.array([0,30,45,60,90])
sin=np.sin(a*np.pi/180)
cos=np.cos(a*np.pi/180)
tan=np.tan(a*np.pi/180)
2.反三角函数
# 求反三角函数的值，以弧度为单位。可以直接利用三角函数所得到的数组sin、cos和tan
arc=np.arcsin(sin)、arccos(cos)、arctan(tan)
# 转化为角度制
deg=np.degrees(arc)
3.其他函数
1.np.around()
# 返回指定数字的四舍五入值
np.around(arr,decimals=0)
decimals:摄入的小数位，默认为0，如果为负，证书将四舍五入到小数点左侧的位置
arr=np.array([1.0,3.456,345,1])
np.around(arr,decimals=-1)
1.0,0,350
2.np.floor()
# 向下取整，总从0舍入，如0.4则从0舍入为0，-1.5从0舍入为-1
np.floor(arr)
3.np.ceil
# 向上取整，如-1.7取整为-1，1.5取整为2
np.ceil(arr)
4.数组间运算
1.数组与数的运算
①在numpy中可以直接利用变量对所有元素进行操作，如果不借助numpy则需要使用for循环
import numpy as np
arr = np.array([[1, 2, 4, 5, 16, 43, 123], [1, 2, 4, 5, 14, 41, 45]])
# 在numpy中可以直接利用变量对所有元素进行操作，如果不借助numpy则需要使用for循环
arr = (arr + 100) / 1
2.数组与数组的运算
①形状相同的数组可以进行运算
②形状不同的数组满足广播机制也可以进行运算
③广播机制：
(1)对应维度上元素个数相等
(2)某一对应的维度元素个数不等，但是其中一个数组该维度元素个数为1
计算结果的形状：从对应维度中选取非1的维度，如果只有1就选1
注：观察方法：写出两个数组的shape，然后右对齐，缺数的就补1
import numpy as np
# arr1两行7列，arr2两行3列
arr1 = np.array([[1, 2, 4, 5, 16, 43, 123], [1, 2, 4, 5, 14, 41, 45]])
arr2 = np.array([1, 2, 3], [4, 5, 5])
# 两个不同形状的数组不可以直接进行运算如：arr1+arr2
# 广播机制(Broadcast)：为了放方便不同形状的ndarray进行运算，则满足一下的规则就可以进行运算
# 1.维度上元素个数相等 2某一维度上元素个数不等但元素个数为1。注从后往前排没有的补1
# 计算结果：非1的维度
# 有两个数组，首先写出维度，如果维度不齐则用1来补(即第二个数组0的位置为1),根据条件可以进行运算，运算结果为2,2,1(非1的数字)
(2, 2, 1) - -[[[1], [2]], [[3], [4]]]
(0, 0, 1) - -[1]
# 运算结果9875
(9, 1, 7, 1)
(0, 8, 1, 5)
(9, 8, 7, 5)
# 下面的不可以进行运算：不满足规则
# 第一组
(3)[1, 2, 3]
(2)[4, 5]
# 第二组
(2, 1) - [[1], [2]]
(3, 2, 3) - [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]], [[12, 14, 15], [16, 17, 18]]]
arr1 = np.array([[[[1], [1], [3]]], [[[4], [5], [6]]]])
arr2 = np.array([[[1, 2]], [[1, 2]]])
arr3 = arr1 + arr2
# 相加结果
[[[[2 3]
[2 3]
[4 5]]
[[2 3]
[2 3]
[4 5]]]
[[[5 6]
[6 7]
[7 8]]
[[5 6]
[6 7]
[7 8]]]]
3.矩阵运算
1.矩阵的说明
①矩阵必须是2维的
②矩阵一定是二维数组，二维数组不一定是矩阵
2.矩阵的存储
# 方式一：np.array(二维数组)，该方法创造出来的数组维nparray类型
arr1 = np.array([[90, 91], [85, 86], [88, 90], [90, 90], [91, 90]]) # 二维：5行2列
print(arr1, type(arr1))
# 方式二：np.mat(二维数组)，该方法创造出来的数组维matri类型
arr2 = np.mat([[90, 91], [85, 86], [88, 90], [90, 90], [91, 90]])
print(arr2, type(arr2))
[[90 91]
[85 86]
[88 90]
[90 90]
[91 90]] <class 'numpy.ndarray'>
[[90 91]
[85 86]
[88 90]
[90 90]
[91 90]] <class 'numpy.matrix'>
3.矩阵的乘法运算
①要求
形状：第一个矩阵的列数和第二个矩阵的行数相等，结果为第一个矩阵的行数第二个矩阵的列数。即(m,n)*(n,l)=(m,l)
运算规则：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cHwhy4v4-1662651263200)(Untitled.assets/矩阵乘法-16626511549905.png)]
import numpy as np
arr1 = np.array([[90, 91], [85, 86], [88, 90], [90, 90], [91, 90]])
arr2 = np.array([[1], [2]])
arr3 = np.mat([[90, 91], [85, 86], [88, 90], [90, 90], [91, 90]])
arr4 = np.mat([[1], [2]])
print(type(arr4))
# 方式一：np.matmul(arr1,arr2),arr1，arr2可以是不同的类型
result = np.matmul(arr1, arr2)
# 方式二：np.dot(arr1,arr2),arr1，arr2可以是不同的类型
result = np.dot(arr3, arr4)
# 方式三：如果至少包含一个matri类型可以直接用*
result = arr1 * arr4
# 方式四：如果全是nparray类型也可以使用@来代替*。因为满足广播机制，因此数组不可以做*，因此要使用矩阵的方法而不是用数组的规则
result = arr1 @ arr2
4.矩阵求逆–np.linalg.inv(arr)
①数组类型求逆:np.linalg.inv(arr)
② mat类型和数组类型求逆： arr.I
# 数组类型求逆:np.linalg.inv(arr)
a = np.array([[1, 2], [3, 4]]) # 初始化一个非奇异矩阵(数组)
print(np.linalg.inv(a)) # 对应于MATLAB中 inv() 函数
# mat类型和数组类型求逆： arr.I
A = np.mat(a)
print(A.I)
print(np.linalg.inv(A))
5.算数运算
①add()、subtract()、multiply()、divide()：±*/
# 和一维数组做运算，会将三维数组的每一行与一维数组做运算(如果该一维数组是列则是列元运算，但是结果一样)
x = np.arange(9, dtype='f').reshape(3, 3)
y = np.array([10, 10, 10])
print(x)
print(y)
print(np.add(x, y))
print(np.subtract(x, y))
print(np.multiply(x, y))
print(np.divide(x, y))
②reciprocal()
# 返回参数元素的倒数
x = np.array([0.25,0.5,1,100])
np.reciprocal(x)
③power()
# 将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
x = np.array([10,10,10])
y = np.array([2,3,4])
np.power(x,y)
100 1000 10000
④mod()、remainder()
# 计算输入数组中相应元素的相除后的余数
x = np.array([10,10,10])
y = np.array([2,3,4])
np.mod(x,y)
mp,remainder(x,y)
14.字符串函数
1.np.char.add()
# 对两个数组的元素进行字符串连接
np.char.add(['str1'],['str2'])
np.char.add(['str1','str2'],['str3','str4'])
str1与str3进行拼接，st2与str4进行拼接
2.np.char.multiply()
# 返回按元素多重连接后的字符串
np.char.multiply('good',3)
goodgoodgood
3.np.char.center()
# 将字符串居中，并使用指定字符在左侧和右侧进行填充
np.char.center(['nice','handsome'],20,fillchar='+')
将数组设定为20个长度，如果不够用+来补充
['++++++++nice++++++++','++++++handsome++++++']
4.np.char.capitalize()
# 将字符串第一个字母转换为大写，中间的字母如果有大写都变为小写
np.char.capitalize(['sunck is a good man','kaige is a nice man'])
['Sunck is a good man','Kaige is a nice man']
5.np.char.title()
# 将字符串的每个单词的第一个字符转为为大写
np.char.title(['sunck is a good man','kaige is a nice man'])
['Sunck Is A Good Man','Kaige Is A Nice Man']
6.np.char.lower()
# 数组元素转换为小写
np.char.lower(['sunck is a good man','kaige is a nice man'])
7.np.char.upper()
# 数组元素转换为大写
np.char.upper(['sunck is a good man','kaige is a nice man'])
8.np.char.splitlines()
# 以单词进行分割
np.char.split(['sunck is a good man','kaige is a nice man'])
list(['suck','is'...])
list(['kaige','is'...])
# 返回元素中的行列表，以换行符分割(在\n处分割)
np.char.splitlines(['sun\nck is a go\nod man','kaige is a nice man'])
list(['sun','ck'...])
9.np.char.strip()
# 移除元素开头或结尾处的特定字符
np.char.strip(['*****123**','*****456***'],*)
['123','456']
10.np.char.join()
# 通过指定分隔符来连接数组中的元素
# 只有一个分隔符就用此分隔符进行分割
np.char.join('-',['nice','good'])
['n-i-c-e','g-o-o-d']
# 分隔符与字符串一样，对应列表位置用对应的分隔符分割
np.char.join(['+''-'],['nice','good'])
['n+i+c+e','g-o-o-d']
# 字符串多分隔符少，多出来的用分隔符的组合分割
np.char.join(['+''-'], ['nice', 'good', 'ok','123'])
['n+-i+-c+-e' 'g+-o+-o+-d' 'o+-k' '1+-2+-3']
# 分隔符多字符串少，按字符串从后往前依次分配分隔符，第一个字符串用其余分隔符的组合
np.char.join(['+''-','*','/'], ['nice', 'good','asda'])
['n+-i+-c+-e' 'g*o*o*d' 'a/s/d/a']
11.np.char.replace()
# 使用新字符串替换字符串中所有的子字符串
np.char.replace(['sunck is a good man','kaige is a good man'],'good','some')
#将所有的good换成some
['sunck is a some man','kaige is a some man']
12.np.char.encode()
# 编码：数组元素一次调用str.encode
np.char.encode(['sunck','good'],'utf-8')
[b'sunck' b'good']
13.np.chart.decpde()
# 解码：数组元素一次调用str.decode,什么格式编码就什么格式解
a=np.char.encode(['sunck','good'],'utf-8')
np.chart.decpde(a,'utf-8')
['sunck','good']
15.排序函数
1.排序种类
| 种类 | 速度 | 最坏情况 | 工作空间 | 稳定性 |
|---|---|---|---|---|
| 快速排序quicksort | 1 | O（n^2） | 0 | 否 |
| 归并排序mergesort | 2 | O(n*log(n)) | ~n/2 | 是 |
| 堆排序heapsort | 3 | O(n*log(n)) | 0 | 否 |
2.sort()
# 返回输入数组的排序副本
np.sort(a,axis,kind,order)
axis:未设置该值时数组会被展开，axis=0列排序，axis=1行排序
kind:排序算法，默认为quicksort
order:如果数组包含字段，则是要排序的字段
x = np.random.randint(1, 11, 12).reshape(3, 4)
print(x)
# 每一行单独进行排序
a = np.sort(x)
print(a)
# 每一列单独排序
a = np.sort(x, axis=0)
print(a)
# 根据order字段来进行排序，要提前设置一个dtype
dt = np.dtype([('name', 'S10'), ('age', 'int')])
y = np.array([('liming', 34), ('li', 45), ('hanxiao', 24), ('lili', 14)], dtype=dt)
print(y)
b = np.sort(y, order='age')
print(b)
[[ 3 6 6 9]
[ 2 8 4 10]
[ 6 1 9 6]]
[[ 3 6 6 9]
[ 2 4 8 10]
[ 1 6 6 9]]
[[ 2 1 4 6]
[ 3 6 6 9]
[ 6 8 9 10]]
[(b'liming', 34) (b'li', 45) (b'hanxiao', 24) (b'lili', 14)]
[(b'lili', 14) (b'hanxiao', 24) (b'liming', 34) (b'li', 45)]
3.argsort()
# 对输入的数组沿给定轴执行简介排序，排好序后，返回对应数据在原来数组中的的索引
np.argsort(arr)
arr = np.array([3, 1, 4])
a = np.argsort(arr)
# 利用索引来获取排好序后的元素
b = arr[a]
# 或利用循环来获取排好序后的元素
for index in arr
print(arr[index])
排序前元素
[3 1 4]
排序后索引数组
[1 0 2]
排序后元素
[1 3 4]
4.lexsort()
# 按键排序，返回一个索引数组，最后一个键恰好是sort的主键
np.lexsort()
x=('raju','anil','ravi','amar')
y=('f.y','s.y','s.y','f.y')
a=np.lexsort(x,y)
[3,1,0,2]
5.sort_complex()
# 对负数按照先实部后虚部的顺序进行排序
np.sort_complex(x)
1+2j 2-1j 3 3+5j 3+4j
1+2j 2-1j 3+4j 3+5j
6.partition()
# 比n打的放在n的前面，比n小的放在n的后面
np.partition(arr,n)
# 比a小的放a的左边，比b大的放a的右边，其他的放中间
np.partition(arr,（a,b）)
7.argpartition()
# 找到arr中第n+1小的数放左边，第n+1大的数放右边，返回索引
argpartition(arr,n)
16.IO操作、数据处理(了解)
1.IO函数
①numpy可以读写磁盘上的文本数据或二进制数据
②numpy为ndarray对象引入了一个简单的文件格式：npy
③npy文件用于存储重建ndarray所需的数据、图形、dtype和其他信息
| 常用IO函数 | 作用 |
|---|---|
| load()和save() | 读写文件数组数据的两个主要函数，默认情况下，数组时以未压缩的原始二进制格式保存在扩展名为.npy的文件中 |
| savez() | 用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式存在扩展名为.npz的文件中 |
| loadtxt()和savetxt() | 处理正常的文本文件(.txt等) |
1.np.save与np.load()
# 将数组保存到以.npy为扩展名的文件中
np.save(file,arr,allow_pickle=True,fix_imports=True)
y=np.load(file)
2.np.savez()
# 将多个数组保存到以npz为扩展名的文件中
np.savez(file,x,y...,kwds)
kwds:要保存的数组使用关键字名称
np.savez(file,arr1,arr2,arr3,arr=z)
y=np.load(file)
print(yp[arr_0])arr_0~arr_1，最后一个要使用sin_arr
3.savetxt()与loadtxt()
%d：以整数保存
np.savetxt(file,arr,fmt='%d',delimiter='分隔符')
y=np.loadtxt(file,dtype=int,delimiter='分隔符')
2.IO操作与数据处理
1.np.genfromtxt(‘文件路径’,delimiter=‘分隔符’)–读取文件
①np.genfromtxt(‘文件路径’,delimiter=‘分割符’)：读取数据文件，delimiter表示用什么来进行分割,由于读取的字符串为nan因此，一般不使用
import numpy as np
# np.genfromtxt('文件路径',delimiter=',')：读取数据文件，delimiter表示用什么来进行分割,由于读取的字符串为nan因此，一般不使用
data = np.genfromtxt('D:/百度网盘/百度网盘下载内容/Python数据挖掘基础教程资料/资料二/day2资料/02-代码/test.csv',
delimiter=',')
# [[ nan nan nan nan]
# [ 1. 123. 1.4 23. ]
# [ 2. 110. nan 18. ]
# [ 3. nan 2.1 19. ]]
print(type(data[2, 2])) # <class 'numpy.float64'>
②缺失值：当我们读取本地文件为float的时候，如果有缺失值（或None），就会出现nan，nan为float类型
③怎么处理缺失值nan
(1)直接删除含有缺失值得样本
(2)替换/插补：求nan所在列非nan数据的平均值或中位数，然后放到nan处（用pandas来完成，用numpy完成很麻烦）
def fill_nam_by_column_mean(t):
for i in range(t.shape[1]):
# 计算nan的个数
nan_num = np.count_nonzero(t[:, i][t[:, i] != t[:, i]])
if nan_num > 0:
now_col = t[:, i]
now_col_not_nan = now_col[np.isnan(now_col) == False].sum()
now_col_mean = now_col_not_nan / (t.shape[0] - nan_num)
now_col[np.isnan(now_col)] = now_col_mean
t[:, i] = now_col
return t
fill_nam_by_column_mean(data)
17.拷贝
1.赋值–浅拷贝
①一个数组发生变化另一个也会发生改变，如y=x，改变y的形状x也会改变
2.视图–浅拷贝
①如切片
②arr.view()可以创建一个视图，修改视图数据，原来的数据也会改变，但是修改形状原来的数组不会改变
3.副本–深拷贝
①copy
llow_pickle=True,fix_imports=True)
y=np.load(file)
1304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
