数据分析手册-numpy数组(1)

numpy数组(import numpy as np)

常见的创建数组函数

np.zeros (10, dtype=int)--创建一个长度为10的数组，数组的值都是0

np.ones((3,5), dtype=float)--创建一个3×5的浮点型数组，数组的值都是1

np.full((3, 5),3.14) --创建一个3×5的浮点型数组，数值都是3.14

np.arrge(0,20,2)--创建一个线性序列数组；从0开始，到20结束，步长为2；（它和内置的range函数类似）

np.linspace(0,1,5)--创建一个5个元素的数组，这5个数均匀地分配到0~1

np.random.random((3,3))--创建一个3×3的、在0~1均匀分布的随机数组成的数组

np.random.normal(0,1,(3,3))--创建一个3×3的、均值为0、标准差为1的正太分布的随机数数组

np.random.randint(0,10,(3,3))--创建一个3×3的、[0,10)区间的随机整型数组

np.eye(3)--创建一个3×3的单位矩阵

mp.empty(3)--创建一个由3个整型数组成的未初始化的数组；数组的值是内存空间中的任意值

通过设置种子来让生成的随机数可预测

import numpy as np
np.random.seed(0)
x1=np.random.randint(10,size=6)
x2=np.random.randint(10,size=(3,4))
x3=np.random.randint(10,size=(3,4,5))
print(x1)
print("-----")
print(x2)
print("-----")
print(x3)
print("-----")

数组处理
1. 利用数组切片获取子数组
X[start:stop:step]– 其默认值分别为0，数组长度(SIZE OF THE DIMENSION)、1

在步长为负数的时候，默认start和stop会进行交换，从而进行反向切割-也就是逆序数组

对于多维子数组，同样可以使用多维切片来进行处理。用逗号进行分隔
```
x2[:2, :3] #两行三列

x2[::-1, ::-1] #从最后一个数开始进行逆序切
```
1. 获取数组的单行和单列
```
x2[:, 0] #获取数组的第一列
x2[0]=x2[0, :]#获取数组的第一行 解释：逗号前面0代表索引0第一行，后面是列，不写代表整个这一列
```

3 .numpy数组切片切到的子数组返回的是原数组的视图而不是副本

--意思是我们修改切割得到的子数组，原数组相应的子数组的值也会发生改变

--意义在于当我们处理非常大的数据集时，可以获取或处理这些数据集的片段，而不用复制底层的数据缓存

4. 创建数组的副本

--明确地复制数组里地数据或子数组有时也是非常有用地，可以通过copy()来进行实现

x2_sub_copy=x2[:2, :2].copy()

5. 数组的变形

数组变形最灵活的实现方式是通过reshape() 函数来实现,这返回的是**原始数组的非副本视图**。

grid=np.arange(1,10).reshape((3,3))
print(grid)
[[1 2 3]
 [4 5 6]
 [7 8 9]]

attention！ 该方法可行的前提条件是原始数组的大小必须和变形后数组的大小一致。如果满足此条件的话，reshape方法将会用到原始数组的一个非副本视图。然而实际情况一般**都是处理非连续的数据缓存**，所以返回非副本视图往往是实现不了的。

另外一种比较常见的变形方式是将一个一维的数组转变为二维的行或列的矩阵–可以通过reshape（）方法或者在一个切片操作中使用newaxis关键字

x=np.array([1,2,3])
#通过变形获得行向量
x.reshape((1,3))
#通过newaxis获得行向量
x[np.newaxis, :]
#通过变形获得列向量
x.reshape((3,1))
#通过newaxis获得列向量
x[:, np.newaxis]

数组拼接和分列

以上所有操作都是针对单一数组的，但有时也需要将多个数组合并为一个，或将一个数组分裂成多个

数组的拼接

拼接或连接numpy中的两个数组主要由np.concatenate、np.vstack和np.hstack例程实现。

np.concatenate–使连接的意思

np.concatenate将数组元组或数组列表作为第一个参数
x=np.array([1,2,3])
y=np.array([3,2,1])
np.concatenate([x,y])
# 也可以一次性拼接两个以上数组:
    z=[99,99,99]
    print(np.concatenate([x,y,z]))
# 也可以用于二维数组的拼接
    grid=np.array([[1,2,3],
                   [4,5,6]])
# 沿着第一个轴拼接
    np.concatenate([grid,grid])
# 沿着第二个轴拼接 （从0开始索引）
    np.concatenate([grid,grid], axis=1)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-efmKwvis-1606470000248)(C:\Users\QXY\AppData\Roaming\Typora\typora-user-images\image-20201127171731980.png)]

沿着固定维度处理数组时，使用np.vstack（垂直栈）和np.hstack(水平栈)函数会更简洁面向代码块编程

x=np.array([1,2,3])
grid=np.array([[9,8,7],
               [6,5,4]])
# 垂直栈数组
np.vstack([x,grid])
#
out:array([[1,2,3],
           [9,8,7]
           [6,5,4]])
# 水平栈数组
y=np.array([[99],
            [99]])
np.hstack([grid,y])
#
out:array([[9,8,7,99],
           [6,5,4,99]])

推广之，np.dstack将沿着第三个维度拼接数组

数组的分裂

与拼接相反的过程是分裂。分裂可以通过np.split、np.hsplit和np.vsplit函数来实现

可以向以上函数传递一个索引列表作为参数，索引列表记录的是分裂点位置：

x=[1,2,3,99,99,3,2,1]
x1,x2,x3=np.split(x,[3,5])
#out:
[1,2,3] [99,99] [3,2,1]

**attention！**值得注意的是，n个分裂点会得到n+1个数组，相关的np.hsplit和np.vsplit的用法也较为类似：

grid=np.arange(16).reshape((4,4))
#out
array([[0,1,2,3],
 [4,5,6,7],
 [8,9,10,11],
 [12,13,14,15]])
upper,lower=np.vsplit(grid,[2]) vsplit--从第三列处水平分割
print(upper)
print(lower)
#out
[[0 1 2 3]
 [4 5 6 7]]
[[8 9 10 11]
 [12 13 14 15]]
left,right=np.hsplit(grid,[2])
print(left)
print(right)
#out
[[ 0 1]
 [ 4 5]
 [ 8 9]
 [12 13]]
[[ 2 3]
 [ 6 7]
 [10 11]
 [14 15]]

同样,np.dsplit可以将数组沿着第三个维度进行分裂

数据分析手册-numpy数组(1)

numpy数组(import numpy as np)

猜你喜欢