文章目录
python基础知识7
本节主要学习numpy的相关知识。
一、munpy是什么？
numpy是一个开源的Python科学计算库，用于快速处理任意维度的数据；支持常见的数组和矩阵操作，对于处理同样的数值计算的任务，numpy优于python直接计算；numpy使用ndarray处理多维数组，该对象是一个灵活而快速的大数据容器
二、numpy的优势
\对于处理同样的数值计算的任务，numpy优于python直接计算；
\numpy中数组的存储效率和输入输出性能均优于Python中等价的基本数据结构且其能够提升的性能与数组中 的元素成比例；
\numpy的大部分代码是用c语言写的，其底层算法在设计时就有优异的性能，这使得numpy比Python高效的多。
例如：对比一下ndarry和Python原生list运算效率的对比。
import random
import time
import numpy as np
a=[]
for i in range(10000000):
a.append(random.random())
t1=time.time()
sum1=sum(a)
t2=time.time()
b=np.array(a)
t4=time.time()
sum3=np.sum(b)
t5=time.time()
print(t2-t1,t5-t4)
输出：
0.21466636657714844
0.061907291412353516
可以看到使用时间缩减了好几倍。
二、Numpy的Ndarray对象
Numpy最重要的一个特点是其对N维数组对象ndarray，它是一系列同一类型数据的集合、多维数组，以0为下标开始进行集合中元素的索引，。
2.1创建一维数组
import numpy as np
list1=[1,2,3,4]
oneArray=np.array(list1)
print(type(oneArray))
print(oneArray)
输出：
<class 'numpy.ndarray'>
[1 2 3 4]
创建数组的多种方式：
1、直接传入列表的方式
t1=np.array([1,2,3,4,5])
print(t1)
print(type(t1))
输出：
[1 2 3 4 5]
<class 'numpy.ndarray'>
2、传入range生成序列
t2=np.array(range(11))
print(t2)
print(type(t2))
输出：
[ 0 1 2 3 4 5 6 7 8 9 10]
<class 'numpy.ndarray'>
3、使用numpy自带的np.arange()生成数组
t3=np.arange(0,12,2)
print(t3)
print(type(t3))
输出：
[ 0 2 4 6 8 10]
<class 'numpy.ndarray'>
2.2创建二维数组
#创建二维数组
import numpy as np
list2=[[1,2],[3,4],[5,6]]
twoArray=np.array(list2)
print(twoArray)
print(type(twoArray))
输出：
[[1 2]
[3 4]
[5 6]]
<class 'numpy.ndarray'>
2.3常用属性
#创建二维数组
import numpy as np
list2=[[1,2],[3,4],[5,6]]
twoArray=np.array(list2)
print(twoArray)
#常用属性
#1、获取数组的维度
print(twoArray.ndim)
#2、获取数组的形状（行、列）
print(twoArray.shape)
#3、查看数组有多少个元素
print(twoArray.size)
输出：
[[1 2]
[3 4]
[5 6]]
2
(3, 2)
6
2.4调整数组的形状
#调整数组的形状
#这是一个两行三列的数组对象
four=np.array([[1,2,3],[4,5,6]])
#修改原有的数组形状，变成3行2列
four.shape=(3,2)
print(four)
print("-----------------")
#返回一个新的数组
four=four.reshape(2,3)
print(four)
print("-----------------")
#将多维数组变成一维数组
five=four.reshape((6,1),order="F")#"F"表示Fortran，即风格的意思，“F”意味着以列的顺序展开，默认情况下是以“C”，即以行的顺序展开
print(five)
print("-----------------")
#拓展数组的形状
t=np.arange(24)
print(t)
print(t.shape)
print("-----------------")
#转换成二维
t1=t.reshape(4,6)
print(t1)
print(t1.shape)
print("-----------------")
#转换成三维
t2=t.reshape((2,3,4))
print(t2)
print(t2.shape)
输出：
[[1 2]
[3 4]
[5 6]]
-----------------
[[1 2 3]
[4 5 6]]
-----------------
[[1]
[4]
[2]
[5]
[3]
[6]]
-----------------
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
(24,)
-----------------
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
(4, 6)
-----------------
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
(2, 3, 4)
2.5将数组转换成列表
a=np.array([9,12,88,14,25])
list_a=a.tolist()
print(list_a)
print(type(list_a))
输出：
[9, 12, 88, 14, 25]
<class 'list'>
三、Numpy的数据类型
f=np.array([1,2,3,4,5],dtype=np.int16)
print(f)
#返回数组中每个元素的字节单位长度
print(f.itemsize)
#获取数据类型
print(f.dtype)
#调整数组类型
f1=f.astype(np.int64)
print(f1.dtype)
#拓展随机生成小数
#使用Python语法，保留两位
print(round(random.random(),2))
arr=np.array([random.random()for i in range(10)])
print(np.round(arr,2))
输出：
[1 2 3 4 5]
2
int16
int64
0.05
[0.4 0.01 0.94 0.94 0.38 0.7 0.14 0.66 0.3 0.19]
dtype是numpy.dtype类型。
那数组到底有哪些数据类型呢？
四、数组的计算
4.1数组和数的计算
由于numpy的广播机制，因此在运算过程中加减乘除的值被广播到所有的元素上面。
#数组的计算
t1=np.arange(24).reshape((6,4))
print(t1)
print("---------------")
print(t1+2)
print("---------------")
print(t1*2)
print("----------------------")
print(t1/2)
输出：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
---------------
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]
[14 15 16 17]
[18 19 20 21]
[22 23 24 25]]
---------------
[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]
[24 26 28 30]
[32 34 36 38]
[40 42 44 46]]
----------------------
[[ 0. 0.5 1. 1.5]
[ 2. 2.5 3. 3.5]
[ 4. 4.5 5. 5.5]
[ 6. 6.5 7. 7.5]
[ 8. 8.5 9. 9.5]
[10. 10.5 11. 11.5]]
4.2数组和数组之间的操作
同种形状的数组（对应位置进行计算）
#同种数组之间的操作
t1=np.arange(24).reshape((6,4))
t2=np.arange(100,124).reshape((6,4))
print(t1)
print(t2)
print(t1+t2)
print(t1*t2)
输出：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[[100 101 102 103]
[104 105 106 107]
[108 109 110 111]
[112 113 114 115]
[116 117 118 119]
[120 121 122 123]]
[[100 102 104 106]
[108 110 112 114]
[116 118 120 122]
[124 126 128 130]
[132 134 136 138]
[140 142 144 146]]
[[ 0 101 204 309]
[ 416 525 636 749]
[ 864 981 1100 1221]
[1344 1469 1596 1725]
[1856 1989 2124 2261]
[2400 2541 2684 2829]]
不同形状的多维数组不能计算
#不同形状的多维数据不能计算
t1=np.arange(24).reshape((6,4))
t2=np.arange(18).reshape((3,6))
print(t1+t2)
print(t1*t2)
-----------------------------------------------------------------------
报错：ValueError Traceback (most recent call last)
<ipython-input-60-eddd872f8c18> in <module>
3 t2=np.arange(18).reshape((3,6))
4
----> 5 print(t1+t2)
6 print(t1*t2)
ValueError: operands could not be broadcast together with shapes (6,4) (3,6)
行数或者列数和多维数组可以进行计算：
行形状相同：
t1=np.arange(24).reshape((6,4))
t2=np.arange(0,4)
print(t1,t2)
print(t2-t1)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[0 1 2 3]
[[ 0 0 0 0]
[ -4 -4 -4 -4]
[ -8 -8 -8 -8]
[-12 -12 -12 -12]
[-16 -16 -16 -16]
[-20 -20 -20 -20]]
列形状相同：
t1=np.arange(24).reshape((4,6))
t2=np.arange(4).reshape((4,1))
print(t1,t2)
print(t1-t2)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
[[0]
[1]
[2]
[3]]
[[ 0 1 2 3 4 5]
[ 5 6 7 8 9 10]
[10 11 12 13 14 15]
[15 16 17 18 19 20]]
五、数组中的轴
5.1数组中的轴
什么是轴：在numpy中可以理解为方向，使用0，1，2数字表示，对于一维数组，只有一个0轴。对于二维数组，有0轴和1轴，对于3维数组，有0,1,2轴。
为什么使用轴：有了轴的概念，计算会更加方便。
计算二维数组
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(np.sum(a,axis=0))#计算0轴上数组的和
print(np.sum(a,axis=1))#计算1轴上数轴的和
print(np.sum(a))#计算所有值的和
输出：
[5 7 9]
[ 6 15]
21
计算三维数组，先打印一下原始的三维数组：
a=np.arange(27).reshape(3,3,3)
print(a)
输出：
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]
[[18 19 20]
[21 22 23]
[24 25 26]]]
计算axis=0上的和的值
#计算axis=0上的和的值，也就是各维对应索引元素的和，
#例如一维索引为1的值加上二维索引为1的值再加上三维索引为1的值，
#三者之和就是最后呈现的数组的索引为1的数组值
a=np.arange(27).reshape(3,3,3)
b=np.sum(a,axis=0)
print(b)
输出：
[[27 30 33]
[36 39 42]
[45 48 51]]
计算axis=1上的和的值
计算axis=1上的和的值，各维度内各列的和，最后依照维度先后次序组合到一个数组中
c=np.sum(a,axis=1)
print(c)
输出：
[[ 9 12 15]
[36 39 42]
[63 66 69]]
计算axis=2上的和的值
计算axis=2上的和的值，各维度内各行的和，最后依照维度先后次序组合到一个数组中
d=np.sum(a,axis=2)
print(d)
输出：
[[ 3 12 21]
[30 39 48]
[57 66 75]]
画了一个草图
总结：数组之间的计算在二维和三维上有所区别，记住在二维中0表示列，1表示行。
六、数组的索引和切片
6.1一维数组的操作方法
#一维数组的操作方法
import numpy as py
a=np.arange(10)
print(a[2:7:2])#从索引2开始，到索引7结束，间隔步长为2。
#如果只放置一个参数，则返回与该索引位置对应的单个元素。
print(a[3],a)
#如果是[2:]，则表示从该索引开始以后的所有项都被提取。
print(a[2:])
输出：
[2 4 6]
3 [0 1 2 3 4 5 6 7 8 9]
[2 3 4 5 6 7 8 9]
6.2多维数组的操作方法
取行：
#多维数组的操作方法
#取行
import numpy as np
t1=np.arange(24).reshape(4,6)
print(t1)
print("---------------------")
print(t1[0])#取一行，一行代表一条数据，索引从0开始
print("---------------------")
print(t1[1,:])#取索引为1的那一行
print("---------------------")
print(t1[1:])#取连续的多行
print(t1[1:3,:])#取连续的多行
print("---------------------")
print(t1[[0,2,3]])#取不连续的多行
print(t1[[0,2,3],:])#取不连续的多行
取列：
#取列
import numpy as np
t1=np.arange(24).reshape(4,6)
print(t1)
print("---------------------")
print(t1[:,1])#取索引为1的行
print("---------------------")
print(t1[:,1:])#取连续的多行
print("---------------------")
print(t1[:,[0,2,3,4]])#取不连续的多行
输出：
[[ 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 7 13 19]
---------------------
[[ 1 2 3 4 5]
[ 7 8 9 10 11]
[13 14 15 16 17]
[19 20 21 22 23]]
---------------------
[[ 0 2 3 4]
[ 6 8 9 10]
[12 14 15 16]
[18 20 21 22]]
取某个值：
import numpy as np
t1=np.arange(24).reshape(4,6)
print(t1)
#取某个值，三行四列
print("---------------------")
print(t1[2,3])
#取多个不连续的值：
print("---------------------")
print(t1[[0,1,1],[0,1,3]])
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
---------------------
15
---------------------
[0 7 9]
七、数组中的数值修改
修改某一行的值
#数组中修改数值
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
#修改某一行的值
t[1,:]=0
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 1 2 3 4 5]
[ 0 0 0 0 0 0]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
修改某一列的值：
#数组中修改数值
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
#修改某一列的值
t[:,1]=0
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
-------------------
[[ 0 0 2 3 4 5]
[ 6 0 8 9 10 11]
[12 0 14 15 16 17]
[18 0 20 21 22 23]]
修改连续多行的值：
#修改连续的多行
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
t[1:3,:]=0
print(t)
输出：[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 1 2 3 4 5]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 19 20 21 22 23]]
修改连续的多列：
#修改连续的多列
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
t[:,1:4]=0
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 0 0 0 4 5]
[ 6 0 0 0 10 11]
[12 0 0 0 16 17]
[18 0 0 0 22 23]]
修改多行多列，取第二行到第四行，第三列到第五列
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
t[1:4,2:5]=0
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 1 2 3 4 5]
[ 6 7 0 0 0 11]
[12 13 0 0 0 17]
[18 19 0 0 0 23]]
修改多个不相邻的点
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
t[[0,2],[0,3]]=0
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 0 16 17]
[18 19 20 21 22 23]]
可以根据条件进行修改：
#比如将小于10的值全部去掉
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
t[t<10]=0
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 0 0 0 0 0]
[ 0 0 0 0 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
使用逻辑判断：
#可以使用逻辑判断：
'''与 &
或 or
非 ~'''
import numpy as np
t=np.arange(24).reshape(4,6)
print(t)
print("--------------------")
t[(t<10)&(t>2)]=0#与
print(t)
print("--------------------")
t[(t<5)&(t>10)]=0#或
print(t)
print("--------------------")
t[~(t>6)]=0#非
print(t)
输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 1 2 0 0 0]
[ 0 0 0 0 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 1 2 0 0 0]
[ 0 0 0 0 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
--------------------
[[ 0 0 0 0 0 0]
[ 0 0 0 0 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
拓展：三目运算
score=np.array([[80,88],[82,81],[75,81]])
result=np.where(score>80,True,False)
print(result)
输出：
[[False True]
[ True True]
[False True]]
八、数组添加、删除和去重
8.1数组的添加
numpy.append函数在数组的末尾添加数值，追加操作会分配整个数组，并把原来的数组复制到新数组中，此外，输入数组的维度必须匹配，否则将生成ValueError。注意：最多两个数组进行拼接，不能三个及以上数组进行拼接。
数组的添加：
#数组的添加
a=np.array([[1,2,3],[4,5,6]])
print("第一个数组：")
print(a)
print("\n")
print("向数组中添加元素： ")
print(np.append(a,[7,8,9]))
print("\n")
print("沿轴0中添加元素： ")
print(np.append(a,[[7,8,9]],axis=0))
print("\n")
print("沿轴1中添加元素： ")
print(np.append(a,[[5,5,5],[7,8,9]],axis=1))
print("\n")
输出：
第一个数组：
[[1 2 3]
[4 5 6]]
向数组中添加元素：
[1 2 3 4 5 6 7 8 9]
沿轴0中添加元素：
[[1 2 3]
[4 5 6]
[7 8 9]]
沿轴1中添加元素：
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]
参数说明：
a:表示输入数组；
value:要向arr中添加的值，需要和arr的形状相同。
axis：默认为None，当无定义的时候，是横向添加，返回的一维数组。当axis有定义时，分别为0或者1，当为0，列数要相同，当为1，行数要相同。
numpy.insert
#函数在给定索引之前，沿着给定轴在输入数组中插入值。
#如果值的类型转换为要插入，，则与它的输入组不同，插入没有原地的，会返回一个新数组，如果没有提供轴，则输入数轴会被展开
import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
print("第一个数组：")
print(a)
print("\n")
#print("未传递Axis参数.在插入之前输入数组会被展开")
print(np.insert(a,3,[11,12]))
#print("传递了Axis参数.会广播值数值来配输入数组")
#沿着axis=0轴广播
print(np.insert(a,1,[11],axis=0))
#沿着axis=1轴广播
print(np.insert(a,1,11,axis=1))
输出：
第一个数组：
[[1 2]
[3 4]
[5 6]]
[ 1 2 3 11 12 4 5 6]
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
8.2数组的删除
numpy.delete
函数返回从输入数组中删除指定子数组的新数组。与insert（）函数的情况一样，如果没有提供轴参数，则输入数组将被展开。
#numpy.delete
import numpy as np
a = np.arange(12).reshape(3,4)
print("第一个数组：")
print(a)
print("\n")
#print("未传递Axis参数.在插入之前输入数组会被展开")
print(np.delete(a,5))
print("\n")
#删除第二列，或者每一行中的第二列
print(np.delete(a,1,axis=1))
输出：
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[ 0 1 2 3 4 6 7 8 9 10 11]
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
参数说明：
arr:输入数组；
obj:可以被切片，整数或整数数组，表明从输入数组删除的子数组；
axis:沿着它删除指定数值的值，如果没有提供，输入数组会被展开；
8.3数组的去重
numpy.unique用于去除数组中相同的元素。
import numpy as np
a=np.array([5,2,6,7,5,6,8,2,9])
print(a)
print("\n")
#第一个数组的去重值
u=np.unique(a)
print(u)
print("\n")
#去重数组的索引数组
u,indices=np.unique(a,return_index=True)
print(indices)
print("\n")
#去重数组的下标
u,indices=np.unique(a,return_inverse=True)
print(indices)
print("\n")
#返回去重元素的重复数量
u,indices=np.unique(a,return_counts=True)
print(indices)
输出：
[5 2 6 7 5 6 8 2 9]
[2 5 6 7 8 9]
[1 0 2 3 6 8]
[1 0 2 3 1 2 4 0 5]
[2 2 2 1 1 1]
参数说明：
return_index：如果是true,返回新的列表元素在旧的列表中的位置（下标），并以列表形式存储；
return_inverse：如果是true,返回旧的列表元素在新的列表中的位置（下标），并以列表形式存储；
return_counts：如果是true,返回去重数组中的元素在原数组中的出现次数。
九、numpy的计算
#numpy的计算
import numpy as np
score=np.array([[80,88],[82,81],[75,81]])
#1、获取所有数据的最大值
result=np.max(score)
print(result)
print("-----------")
#获取某一个轴上的数据最大值
result=np.max(score,axis=0)
print(result)
print("-----------")
#2、获取最小值
result=np.min(score)
print(result)
print("-----------")
#3、获取某一个轴上的数据最大值
result=np.min(score,axis=0)
print(result)
print("-----------")
#4、数据的比较
result=np.maximum([-2,-1,0,1,2],0)#第一个参数中的每一个数与第二个参数比较返回大的
print(result)
print("-----------")
result=np.minimum([-2,-1,0,1,2],0)#第一个参数中的每一个数与第二个参数比较返回小的
print(result)
print("-----------")
result=np.maximum([-2,-1,0,1,2],[1,2,3,4,5])#接受两个参数，也可以大小一致，
#第二个参数只是一个单独的值，其实是用到了维度的广播机制。
print(result)
print("-----------")
#5、求平均值
result=np.mean(score)#获取所有数据的平均值
print(result)
print("-----------")
result=np.mean(score,axis=0)#获取某一行或者某一列的平均值
print(result)
print("-----------")
#6、返回给定axis上的累积和
arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr)
print("-----------")
print(arr.cumsum(0))
print("-----------")
print(arr.cumsum(1))
print("-----------")
#7、argmin求最小值索引
result=np.argmin(score,axis=0)
print(result)
print("-----------")
#8、求数据的标准差
result=np.std(score,axis=0)
print(result)
print("-----------")
#9、求极值
np.ptp(result,axis=None)
#拓展：方差var ;协方差cov;计算平均值：average;计算中位数：median
输出：
88
-----------
[82 88]
-----------
75
-----------
[75 81]
-----------
[0 0 0 1 2]
-----------
[-2 -1 0 0 0]
-----------
[1 2 3 4 5]
-----------
81.16666666666667
-----------
[79. 83.33333333]
-----------
[[1 2 3]
[4 5 6]
[7 8 9]]
-----------
[[ 1 2 3]
[ 5 7 9]
[12 15 18]]
-----------
[[ 1 3 6]
[ 4 9 15]
[ 7 15 24]]
-----------
[2 1]
-----------
[2.94392029 3.29983165]
-----------
0.35591135676127283
通用函数：
十、数组的拼接
有时需要将两个数据拼接在一起进行分析。
#1、根据轴连接的数组序列
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
b=np.array([[7,8,9],[10,11,12]])
#要求两个数组维度相同
print(np.concatenate((a,b),axis=0))
print("====================")
print(np.concatenate((a,b),axis=1))
print("====================")
#2、根据轴进行堆叠
print(np.stack((a,b),axis=0))
print("====================")
print(np.stack((a,b),axis=1))
print("====================")
#3、矩阵垂直拼接
v1=[[0,1,2,3,4,5],[6,7,8,9,10,11]]
v2=[[12,13,14,15,16,17],[18,19,20,21,22,23]]
result=np.vstack((v1,v2))
print(result)
print("====================")
#4\矩阵水平拼接
v1=[[0,1,2,3,4,5],[6,7,8,9,10,11]]
v2=[[12,13,14,15,16,17],[18,19,20,21,22,23]]
result=np.hstack((v1,v2))
print(result)
输出：
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
====================
[[ 1 2 3 7 8 9]
[ 4 5 6 10 11 12]]
====================
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
====================
[[[ 1 2 3]
[ 7 8 9]]
[[ 4 5 6]
[10 11 12]]]
====================
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
====================
[[ 0 1 2 3 4 5 12 13 14 15 16 17]
[ 6 7 8 9 10 11 18 19 20 21 22 23]]
十一、数组的分隔
#将数组分割成多个子数组
arr=np.arange(9).reshape(3,3)
b=np.split(arr,3)
print(b)
print("====================")
#numpy.hsplit函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组
harr=np.floor(10*np.random.random((2,6)))
#floor()返回数字的下舍整数
print(harr)
print("====================")
print(np.hsplit(harr,3))
print("====================")
#numpy.vsplit沿着垂直轴分割
a=np.arange(16).reshape(4,4)
b=np.vsplit(a,2)
print(b)
输出：
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
====================
[[2. 6. 8. 4. 5. 2.]
[1. 6. 3. 2. 1. 8.]]
====================
[array([[2., 6.],
[1., 6.]]), array([[8., 4.],
[3., 2.]]), array([[5., 2.],
[1., 8.]])]
====================
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
十二、数组中的nan和inf
inf表示无穷大，需要使用float(“inf”)函数来转换，对应的float("-inf")表示无穷小，这样可以使用任意数来与之比较。
什么时候会出现inf?比如一个数字除以0，Python中会报错，但是numpy会是一个inf或者-inf。
nan在pandas中比较常见，表示数据缺失，任何与其计算的结果都是nan。
#创建一个nan或inf
a=np.nan
b=np.inf
print(a,type(a))
print(b,type(b))
#判断数组中为nan的个数，只有float才能赋值nan
t=np.arange(24,dtype=float).reshape(4,6)
#可以使用np.count_nonzero()来判断非零的个数
print(np.count_nonzero(t))
#将三行四列的数修改成nan
t[3,4]=np.nan
print(np.count_nonzero(t!=t))
#nan和任何数计算都为nan
print(np.sum(t,axis=0))
#将nan替换成0
t[np.isnan(t)]=0
print(t)
输出：nan <class 'float'>
inf <class 'float'>
23
1
[36. 40. 44. 48. nan 56.]
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 0. 23.]]
做个小练习：
#练习处理数组中的nan
t=np.arange(24).reshape(4,6).astype("float")
#将数组中的一部分替换成nan
t[1,3:]=np.nan
print(t)
print("==========================")
#遍历每一列，然后判断每一列是否有nan
for i in range(t.shape[1]):
temp_col=t[:,i]#获取当前列数据
nan_num=np.count_nonzero(temp_col!=temp_col)#判断当前列的数据中是否含有nan
if nan_num!=0:#条件成立说明含有nan
temp_col_not_nan=temp_col[temp_col==temp_col]#将这一列不为nan的数据拿出来
temp_col[np.isnan(temp_col)]=np.mean(temp_col_not_nan)#将nan替换成这一列的平均值
print(t)
输出：
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. nan nan nan]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
==========================
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 13. 14. 15.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
十三、二维数组的转置
```python
a=np.arange(12).reshape(3,4)
print("原数组")
print(a)
print("\n")
print("对换数组: ")
print(np.transpose(a))
#与transpose一致
a=np.arange(12).reshape(3,4)
print("原数组")
print(a)
print("\n")
print("转置数组： ")
print(a.T)
#函数用于交换数组的两个轴
t1=np.arange(24).reshape(4,6)
re=t1.swapaxes(1,0)
print("原数组")
print(a)
print("\n")
print("调用swapaxes函数后的数组")
print(re)
输出：
原数组
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
对换数组:
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
原数组
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
转置数组：
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
原数组
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
调用swapaxes函数后的数组
[[ 0 6 12 18]
[ 1 7 13 19]
[ 2 8 14 20]
[ 3 9 15 21]
[ 4 10 16 22]
[ 5 11 17 23]]
总结：
125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
