数据预处理01

numpy简介

numpy-ndarray对象即n维数组对象
该对象封装了同质数据类型的n维数组（数组，即有序的元素序列）

创建ndarray数组

一、np.array函数
二、随机数函数生成array
三、用arange函数创建array
四、创建特殊数组函数

方法一： np.array函数创建ndarray
np.array()；

arr1=np.array([1,3.14,2],ndmin=2);#ndmin指定多少维数组
arr2=np.array([[1,3.14,2],[2,5.6,0]]);

方法二：np.random函数创建ndarray
np.random.randint()；

arr3=np.random.randint(10,size=4);#上限为10
arr4=np.random.randint(20,size=(4,5));

np.random.rand()；

arr5=np.random.rand(2,3,4);
#第一个维度2个元素，第二个维度3个元素，第三个维度上4个元素;但是元素数值从0-1服从均匀分布

np.random.uniform()

arr6=np.random.uniform(1,10,size=(2,3));
#相比较上者可以设置元素取值范围

np.random.random()

arr7=np.random.random((2,3,2))
#与np.random.rand作用类似；元素取值0-1随机浮点数并服从连续均匀分布，参数为元组形式

np.random.randn()

arr8=np.random.randn(2,3)
#元素取值服从标准正态分布

方法三：arange函数创建array 默认一维

arr9=np.arange(1,10,2);#下限1，上限10（不包括上限），步长2

方法四：创建特殊数组函数
全0数组

arr10=np.zeros(3)  #三个元素的一维数组,默认浮点类型
arr11=np.zeros((3,3),dtype=int)#3乘3的二维数组，第一个维度3，第二个维度3，元素类型为int型

全1数组

arr12=np.ones(3);  #三个元素的一维数组,默认浮点类型
arr13=np.ones((3,3),dtype=int);#3乘3的二维数组，第一个维度3，第二个维度3，元素类型为int型

全n数组

arr14=np.full(3,4);  #指定一维数组,元素个数3，元素为4默认浮点类型
arr15=np.full((3,3),4,dtype=int);#3乘3的二维数组，第一个维度3，第二个维度3，元素为4，元素类型为int型

生成线性序列

arr16=np.linspace(1,10);  #指定生成元素下限1，上限10；默认生成元素个数50个
arr17=np.linspace(10,1);  #相对上者，逆序输出即可
arr18=np.linspace(1,10,5,endpoint=False,retstep=True); #指定元素个数5个,不包含上限,显示步长

创建单位矩阵 默认数值类型为浮点型

arr19=np.eye(3);#3乘3单位矩阵
arr20=np.eye(3,4);#3乘4普通单位矩阵
arr21=np.eye(5,k=2);#5乘5单位矩阵，对角线向上偏移2

创建对角矩阵np.diag(values,k)

arr22=np.diag([1,2,3],1);#通过对角线值控制矩阵大小；对角线值1,2,3，对角线向上偏移1

数组的属性

ndarray.shape() 返回包含数组维度的元组
ndarray.dtype() 返回数组内元素的类型
ndarray.ndim() 返回数组的维数
ndarray.size() 返回数组中包含元素的个数

np.random.seed(123)
arr23=np.random.randn(6) #一维数组  浮点数，标准正态分布
arr24=np.random.randint(10,size=(2,4))#二维数组
arr25=np.random.randint(20,size=(2,3,4))#三维数组
print(arr23.shape);
print(arr23.dtype);
print(arr23.ndim);
print(arr23.size);

numpy的矢量化功能
引问题

a=[1,11,111]
b=[2,22,222]
print(a+b)  #[1, 11, 111, 2, 22, 222]  合并列表而非列表中值相加

实现列表中值相加

a=[1,11,111]
b=[2,22,222]
c=[]
for i in range(len(a)):
    c.append(a[i]+b[i])
print(c)#[3, 33, 333]   列表值相加

转数组实现运算

a=[1,11,111]
b=[2,22,222]
arr26=np.array(a)#列表转数组
arr27=np.array(b)
print(arr26+arr27)  #数组中元素相加
print(arr26/arr27)  #数组中元素相除

ndarray的各种变换操作

ndarray.reshape 维度变换
ndarray.resize 维度变换
ndarray.tolist 类型变化
ndarray.astype 元素类型变换

reshape 实际并没有改变原数组，只不过是改变了视图而已
resize则是直接更改原数组

arr28=np.random.randint(1,100,(2,3))#一2乘3的矩阵
arr29=arr28.reshape((3,2))#输入参数为所要改变的矩阵的维度
print(arr28)
arr30=np.arange(1,10).reshape(3,3)#arange只能生成一维数组，可由此改变维度
arr31=np.linspace(1,10,20).reshape(4,5)#生成20个元素取值范围为1到10的一维数组
#resize则是直接更改原数组
arr28.resize((3,2))
print(arr28)

astype 改变数组内元素数据类型,但不改变原数组

print(arr28.astype(str))

数组改变为其它数据类型

print(arr28)
print(arr28.tolist())#转换为列表[[70, 65], [76, 35], [59, 11]]
print(list(arr28))#[array([70, 65]), array([76, 35]), array([59, 11])]

广播

满足以下条件之一，数组称为可广播：
如果数组不具有相同的秩，则将较低等级数组的形状维度添加1，直到两个形状具有相同的大小.
其中一个数组的维度大小和元素个数为1，相当于对单个标量进行广播
在一个数组的大小为1且另一个数组的大小大于1的任何维度中，第一个数组的行为就像沿着该维度复制一样

一.如果运算的双方一方是数组，一方是标量（单个的数值），不受广播方向的约束，可以向两个方向广播
二.如果运算的双方都是数组，且数组的形状不一致，呢么，一个数组向一个方向广播之后可以得到和另一个数组一样的形状，则广播可行
三.如果运算双方都是数组，且数组形状不一致，呢么，两个数组各自向一个广播，广播后的两个数组形状相同，则广播可行

arr30=np.array([1,2,3]);
arr31=np.array([1])
#第一种情况   print(arr31+arr30)等同于print(arr30+1)
arr32=np.ones((3,3),dtype=int);
#第二种情况   print(arr32+arr30)
arr33=np.full((3,1),2,dtype=int)
#第三种情况   print(arr33+arr30)
arr34=np.full((2,2),1,dtype=int)
arr35=np.full((3,3),2,dtype=int)
#不满足广播条件的情况，报错   print(arr34+arr35)

访问ndarray中元素-索引和切片

arr36=np.random.randint(10,size=8)

[6 2 4 4 6 3 0 6]注意索引从0开始到7结束

切片语法 ndarry(start:stop:step)
如果start被省略,默认从第0个位置开始切片
如果stop被省略,默认切片到最后,包含最后位置的元素
如果step被省略,默认步长为1

arr36[:]  #从头到尾全部元素
arr36[2:5] #[4 4 6] 不包含指定终止值
arr36[1:6:2]  #[2 4 3]步长为2

#反向切片要注意切片方向和步长方向要一致
arr36[-2:-5:-1]   #[0 3 6]  倒数第二位即-2位置是0
arr36[::-1]   #等同于arr36[-1:-9:-1]    [6 0 3 6 4 4 2 6]逆序输出
arr36[-1:0:-1] #等同于arr36[-1:-8:-1]    [6 0 3 6 4 4 2]

高维数组切片

arr37=np.random.randint(1,30,size=(2,3,4))

[[[15 21 8 12]
[23 8 2 12]
[27 6 24 26]]

[[19 21 25 18]
[13 19 18 2]
[20 13 22 10]]]

print(arr37[1])
'''
[[19 21 25 18]
 [13 19 18  2]
 [20 13 22 10]]'''
 
 print(arr37[0][1])  #[23  8  2 12]
 print(arr37[0][0][2])  #8

注意：通过基本索引和切片切出来的新数组,和原数组之间相互不独立,对其中一个数组内元素进行更改的时候,另一个数组内对应的元素也会发生相应的改变 即是浅拷贝

浅拷贝

arr37_1=arr37[0][1]
arr37_1[1]=99

arr37_1 #[23 99  2 12]
arr37
'''
[[[15 21  8 12]
  [23 99  2 12]
  [27  6 24 26]]

 [[19 21 25 18]
  [13 19 18  2]
  [20 13 22 10]]]
'''

深拷贝 切片出来的数组和原数组之间相互独立,互不影响

arr37_2=arr37[1][1].copy()
arr37_2[1]=99

print(arr37_2)  #[13 99 18  2]
print(arr37)
'''
[[[15 21  8 12]
  [23 99  2 12]
  [27  6 24 26]]

 [[19 21 25 18]
  [13 19 18  2]
  [20 13 22 10]]]'''

整数数组索引切片

切片语法：arr[[元素所在的数组中第0个轴上的位置信息],[元素所在的数组
中第1个轴上的位置信息]…]

高级索引始终返回数据的副本，与原数组之间相互独立

#例1
arr38=np.random.randint(10,size=8) #[0 8 1 6 3 3 5 9]
arr38_1=arr38[[1,3,4,5]]  #[8 6 3 3]  取出一维内索引分别为1,3,4,5处

arr38_1[1]=33   #修改
arr38_1  #[ 8 33  3  3]
arr38  #[0 8 1 6 3 3 5 9]

#例2
arr39=np.random.randint(0,20,size=(2,3,4))
'''[[[ 7  9  2  3]
  [11  3 19  6]
  [ 9 14  6 19]]

 [[ 6 12  6 17]
  [14 10  3  3]
  [ 1 15 13 16]]]'''
arr39_1=arr39[[0,0,1,1],[0,1,0,2],[0,0,1,1]]   #取出7,11,12,15

布尔索引

arr39_1>10
print(arr39_1>10)  #[False  True  True  True]
arr39_2=arr39_1[arr39_1>10]  #[11 12 15]
print(arr39_2)