Numpy基础用法介绍

Numpy使用

什么是Numpy

​ 一个在Python中做科学计算的基础库，重在数值计算，也是大部分Python科学计算库的基础库，多用于在大型、多维数组上执行数值计算。

Numpy数组的创建

import numpy as np
import random
# 使用numpy生成数组
p1 = np.array([1, 2, 3])

print(p1)
print(type(p1))

t2 = np.array(range(10))
print(t2)

t3 = np.arange(0, 10, 2)
print(t3)

print(t3.dtype)
print("*" * 100)

# Numpy中的数据类型
t4 = np.array(range(1, 4), dtype="float32")
print(t4)
print(t4.dtype)

# Numpy中的bool类型
t5 = np.array([1, 1, 0, 1, 0, 0], dtype=bool)
print(t5)
print(t5.dtype)

# 调整数据类型
t6 = t5.astype(int)
print(t6)
print(t6.dtype)

# Numpy中的小数
t7 = np.array([random.random() for i in range(10)])
print(t7)
print(t7.dtype)

t8 = np.round(t7,2)
print(t8)

创建数组：

• 注意arrange和range的区别
  np.arange()的用法：

  numpy.arange(start, stop, step, dtype)
  

  根据start与stop指定的范围以及step设定的步长，生成一个ndarray

参数	描述
start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

数组的类名

• numpy数组的类名为numpy.ndarray

数据的类型

• 我们使用a.dtype来查看当前数组内部元素的数据类型
• 使用a.astype()传入目标数据类型参数，即可转换a中元素的数据类型

Numpy中常用的数据类型

类型	类型代码	说明
int8、uint8	i1、u1	有符号和无符号的8位（1个字节）整型
int16、uint16	i2、u2	有符号和无符号的16位（2个字节）整型
int32、uint32	i4、u4	有符号和无符号的32位（4个字节）整型
int64、uint64	i8、u8	有符号和无符号的64位（8个字节）整型
float16	f2	半精度浮点数
float32	f4或f	标准的单精度浮点数。与C的float兼容
float64	f8或d	标准的双精度浮点数。与C的double和Python的float对象兼容
float128	f16或g	扩展精度浮点数
complex64、complex128、complex256	c8、c16、c32	分别用两个32位、63位或128位浮点数表示的复数
bool	？	存储True和False值的布尔类型

数组的形状

查看数组的形状

• 使用a.shape

修改数组的形状

• 使用a.reshape()，不对数组进行原地修改，而是返回一个新数组
• 如果要将某个数组修改为一维数组，则只能传入一个参数，例如：a.reshape((24,))，或者使用a.reshape(-1)，以及a.flatten()

数组和数的计算

numpy的广播机制会导致在运算中，加减乘除的值会被广播到数组的所有元素上。

数组和数组的计算

广播原则

定义

​ 如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行

理解

# 数组直接对一个数进行加减乘除，产生的结果是数组中的每个元素都会加减乘除这个数。
In [12]: import numpy as np
In [13]: a = np.arange(1,13).reshape((4, 3))
In [14]: a * 2
Out[14]: array([[ 2, 4, 6],
                [ 8, 10, 12],
                [14, 16, 18],
                [20, 22, 24]])
# 接下来我们看一下数组与数组之间的计算
In [17]: b = np.arange(12,24).reshape((4,3))
In [18]: b
Out[18]: array([[12, 13, 14],
                [15, 16, 17],
                [18, 19, 20],
                [21, 22, 23]])
In [19]: a + b
Out[19]: array([[13, 15, 17],
                [19, 21, 23],
                [25, 27, 29],
                [31, 33, 35]])
In [20]: c = np.array([1,2,3])
In [21]: a+c
Out[21]: array([[ 2, 4, 6],
                [ 5, 7, 9],
                [ 8, 10, 12],
                [11, 13, 15]])
In [22]: d = np.arange(10,14).reshape((4,1))
In [23]: d
Out[23]: array([[10],
                [11],
                [12],
                [13]])
In [24]: a + d
Out[24]: array([[11, 12, 13],
                [15, 16, 17],
                [19, 20, 21],
                [23, 24, 25]])
# 从上面可以看出，和线性代数中不同的是，m*n列的m行的一维数组或者n列的一维数组也是可以计算的。

在上面的代码中，a的维度是（4，3），c的维度是（1，3）；d的维度是（4，1）。所以假设有两个数组，第一个的维度是（x_1, y_1, z_1），另一个数组的维度是（x_2, y_2, z_2），要判断这两个数组能不能进行计算，可以用如下方法来判断：

if z_1 == z_2 or z_1 == 1 or z_2 == 1:
    if y_1 == y_2 or y_1 == 1 or y_2 == 1:
        if x_1 == x_2 or x_1 == 1 or x_2 == 1:
            可以运算
        else:
            不可以运算
    else:
        不可以运算
else:
    不可以运算

这里需要注意：（3，3，2）和（3，2）是可以运算的，因为对于二维数组（3，2）也可以表示为（1，3，2），套用上述的规则是完全适用的，同理：（4，2，5，4）和（2，1，4）也是可以进行运算的。

轴（axis）

1. 在二维NumPy数组中，轴是沿行和列的方向

AXIS 0 轴是沿着行（rows）的方向

在NumPy数组中，axis 0 是第一轴。对于二维或多维数组，axis 0 是沿行（row）向下的轴。（一维数组是特例，不适用此处解释，后续讲解）

AXIS 1 轴是沿着列（columns）的方向

在NumPy数组中，axis 1 是第2根轴。对于二维或多维数组，axis 1 是沿列（columns）横穿的轴。

2. 二维或多维数组中axis参数控制的内容

在带有axis参数的二维数组上使用np.sum（）等聚合函数时，它会将二维数组折叠为一维数组。它会折叠数据并减少维度。

axis参数控制将聚合哪个轴，换句话说，axis参数控制哪个轴将被折叠。

将NumPy和函数与axis参数一起使用时，指定的轴是折叠的轴。

示例，先创建一个简单的数组：

分别使用 axis= 0 和 axis= 1 的NumPy求和函数sum：

1. 在二维NumPy数组中，轴是沿行和列的方向

AXIS 0 轴是沿着行（rows）的方向

在NumPy数组中，axis 0 是第一轴。对于二维或多维数组，axis 0 是沿行（row）向下的轴。（一维数组是特例，不适用此处解释，后续讲解）

AXIS 1 轴是沿着列（columns）的方向

在NumPy数组中，axis 1 是第2根轴。对于二维或多维数组，axis 1 是沿列（columns）横穿的轴。

2. 二维或多维数组中axis参数控制的内容

在带有axis参数的二维数组上使用np.sum（）等聚合函数时，它会将二维数组折叠为一维数组。它会折叠数据并减少维度。

axis参数控制将聚合哪个轴，换句话说，axis参数控制哪个轴将被折叠。

将NumPy和函数与axis参数一起使用时，指定的轴是折叠的轴。

示例，先创建一个简单的数组：

分别使用 axis= 0 和 axis= 1 的NumPy求和函数sum：

3. 一维NumPy数组中的axis

一维NumPy数组只有一个轴（即axis=0）

示例：连接1-D阵列（一维数组）

示例：用AXIS = 1连接1-D阵列时的报错

3. 一维NumPy数组中的axis

一维NumPy数组只有一个轴（即axis=0）

示例：连接1-D阵列（一维数组）

示例：用AXIS = 1连接1-D阵列时的报错

numpy读取数据

np.loadtxt(frame,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)

参数	解释
frame	文件、字符串或产生器，可以是.gz或bz2压缩文件
dtype	数据类型，可选，CSV的字符串以什么数据类型读入数组中，默认为np.float
delimiter	分隔字符串，默认是任何空格，改为逗号
skiprows	跳过前x行，一般跳过第一行表头
usecols	读取指定的列，索引，元组类型
unpack	如果True，读入属性将分别写入不同的数组变量，False读入数据只写入一个数组变量 ，默认False，相当于进行了矩阵的转置

a.transpose()、a.T、a.swapaxes(1,0)也可以实现二维数组转置（返回一个新的数组）

注意：a.swapaxes(1,0)只能传入两个参数，实现两个轴的调换，而a.transpose()、a.T都可以实现多维数组的转置，若原数组的形状为（2，3，4），则经过转置后，数组形状为（4，3，2）

import numpy as np

us_file_path = "./youtube_video_data/US_video_data_numbers.csv"
uk_file_path = "./youtube_video_data/GB_video_data_numbers.csv"

# 加载文件数据
t1 = np.loadtxt(us_file_path, delimiter=",", dtype="int")


# 转置的测试
# t2 = np.arange(24).reshape(2,3,4)
# print(t2)
# print('*'*100)
# print(t2.swapaxes(2,1))
# print(t2.transpose())
# print(t2.T)

print(t1)

Numpy的索引和切片

普通索引

import numpy as np

us_file_path = "./youtube_video_data/US_video_data_numbers.csv"
uk_file_path = "./youtube_video_data/GB_video_data_numbers.csv"

t1 = np.loadtxt(us_file_path, delimiter=",", dtype="int")

# 转置的测试
# t2 = np.arange(24).reshape(2,3,4)
# print(t2)
# print('*'*100)
# print(t2.swapaxes(2,1))
# print(t2.transpose())
# print(t2.T)

# print(t1)


# 取行
print(t1[2])
print(t1[2, :])

# 取连续的多行
print(t1[2:])
print(t1[2:, :])

# 取不连续的多行
print(t1[[2, 3, 8]])
print(t1[[2, 3, 8], :])

# 取列
print(t1[:, 0])

# 取连续的多列
print(t1[:, 2:])

# 取不连续的多列
print(t1[:, [0, 2]])

# 取行和列，取第三行、第四列的值
print(t1[2, 3])  # 拿到的数据依然是numpy的数据类型

# 取多行多列，取第三行到第五行，第二列到第四列的结果
# 取的是行和列交叉点的位置
print(t1[2:5, 1:4])

# 取多个不相邻的点
print(t1[[0,2],[0,1]]) # 取到的值是第零行第零列和第二行第一列的值

Numpy中数值的修改

索引到要修改的位置直接进行赋值，就可以实现数值的修改。

Numpy中布尔索引

我们可以通过一个布尔数组来索引目标数组，以此找出与布尔数组中值为True的对应的目标数组中的数据（后面通过实例可清晰的观察）。需要注意的是，布尔数组的长度必须与目标数组对应的轴的长度一致。下面通过几个例子来说明。

一维数组的索引

布尔数组中，下标为0,3,4的位置是True，因此将会取出目标数组中对应位置的元素。

In [24]: arr = np.arange(7)

In [25]: booling1 = np.array([True,False,False,True,True,False,False])

In [26]: arr[booling1]
Out[26]: array([0, 3, 4])

二维数组的索引

布尔数组中，下标为0,3,4的位置是True，因此将会取出目标数组中第0,3,4行。

In [27]: arr = np.arange(28).reshape((7,4))

In [28]: arr
Out[28]: 
array([[ 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, 27]])

In [29]: booling1 = np.array([True,False,False,True,True,False,False])

In [30]: arr[booling1]
Out[30]: 
array([[ 0,  1,  2,  3],
       [12, 13, 14, 15],
       [16, 17, 18, 19]])

我们还可以通过数组的逻辑运算来作为索引（实际上数组的逻辑运算的结果，也就是一个布尔数组）。假设我们有一个长度为7的字符串数组，然后对这个字符串数组进行逻辑运算，进而把元素的结果（布尔数组）作为索引的条件传递给目标数组（本质上，和上面那个例子是类似的）。例如，还是上面例子中的数组arr，现在就胡乱想象成每一行数据是一个人的一个月其中四天赚的钱。这7行中，可能有某些行属于特定的人，那就想象成不同月份赚到的钱。

In [35]: names = np.array(['Ben','Tom','Ben','Jeremy','Jason','Michael','Ben'])

In [36]: names == 'Ben'
Out[36]: array([ True, False,  True, False, False, False,  True], dtype=bool)

# 找出Ben赚的钱的明细
In [37]: arr[names == 'Ben']
Out[37]: 
array([[ 0,  1,  2,  3],
       [ 8,  9, 10, 11],
       [24, 25, 26, 27]])

# 在此基础上，我们还可以添加常规的索引和切片操作
In [38]: arr[names == 'Ben',3]
Out[38]: array([ 3, 11, 27])

In [39]: arr[names == 'Ben',1:4]
Out[39]: 
array([[ 1,  2,  3],
       [ 9, 10, 11],
       [25, 26, 27]])

上面的例子，通过逻辑运算把属于Ben的明细找了出来。那如果我们想查找不属于Ben的明细，则可以通过!=或者~运算。这种逻辑运算，还可以用来做数据清洗，后面会介绍到。

In [40]: arr[names!='Ben']
Out[40]: 
array([[ 4,  5,  6,  7],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])

In [41]: arr[~(names=='Ben')]
Out[41]: 
array([[ 4,  5,  6,  7],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])

多个逻辑运算的与和或也是支持的。例如，找出Tom或者Jason的明细，并且想对他们残忍点，把他们的钱都清零。

In [44]: arr[(names == 'Jason') | (names == 'Tom')]
Out[44]: 
array([[ 4,  5,  6,  7],
       [16, 17, 18, 19]])

In [45]: arr[(names == 'Jason') | (names == 'Tom')] = 0

In [46]: arr
Out[46]: 
array([[ 0,  1,  2,  3],
       [ 0,  0,  0,  0],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [ 0,  0,  0,  0],
       [20, 21, 22, 23],
       [24, 25, 26, 27]])

除此之外，我们也可以目标数组上做逻辑运算。实际上，这种逻辑运算的到的结果是和目标数组维度和长度都一样的布尔数组。例如，找出arr中大于15的元素，与上面的例子不一样，这个例子返回的结果是一个一维数组。

In [51]: arr[arr>15]
Out[51]: array([16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27])

借上面的例子引申一下，假设现在想把上述数组中，小于或者等于15的数归零，类似于数据清洗，那么可以通过下面的方式。

In [139]: arr
Out[139]: 
array([[ 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, 27]])

In [140]: arr[arr<=15]=0

In [141]: arr
Out[141]: 
array([[ 0,  0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  0,  0,  0,  0],
       [ 0,  0, 16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25, 26, 27]])

花式索引 (Fancy Indexing)

花式索引是NumPy用来描述使用整型数组（这里的数组，可以是NumPy的数组，也可以是python自带的list）作为索引的术语，其意义是根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。

In [69]: arr = np.array(['zero','one','two','three','four'])

In [70]: arr[[1,4]]
Out[70]: 
array(['one', 'four'],
      dtype=')
      

In [71]: arr = np.empty((8,4),dtype=np.int)

In [72]: for i in range(8):
    ...:     arr[i] = i
    ...:     

In [73]: arr
Out[73]: 
array([[0, 0, 0, 0],
       [1, 1, 1, 1],
       [2, 2, 2, 2],
       [3, 3, 3, 3],
       [4, 4, 4, 4],
       [5, 5, 5, 5],
       [6, 6, 6, 6],
       [7, 7, 7, 7]])
In [75]: arr[[4,3,0,6]]
Out[75]: 
array([[4, 4, 4, 4],
       [3, 3, 3, 3],
       [0, 0, 0, 0],
       [6, 6, 6, 6]])

In [76]: arr[[-3,-5,-7]]
Out[76]: 
array([[5, 5, 5, 5],
       [3, 3, 3, 3],
       [1, 1, 1, 1]])

对于使用两个整型数组作为索引的时候，那么结果是按照顺序取出对应轴的对应下标的值。特别注意，这两个整型数组的shape应该一致，或者其中一个数组应该是长度为1的一维数组（与NumPy的Broadcasting机制于关系）。例如，以[1,3,5],[2,4,6]这两个整型数组作为索引，那么对于二维数组，则取出(1,2),(3,4),(5,6)这些坐标对应的元素。

In [77]: arr = np.arange(42).reshape(6,7)

In [78]: arr
Out[78]: 
array([[ 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, 27],
       [28, 29, 30, 31, 32, 33, 34],
       [35, 36, 37, 38, 39, 40, 41]])

In [79]: arr[[1,3,5],[2,4,6]]
Out[79]: array([ 9, 25, 41])

Numpy中的三元运算符

np.where(t<10,0,10)

将满足条件的数值修改为第二个参数值，不满足条件的数值修改为第三个参数值。

Numpy中的clip（裁剪）

t.clip(10,18)

小于10的全部替换成10，大于18的全部替换成18，但是nan不会被替换。

Numpy中数组的拼接

接下来介绍我所知道的四种numpy数组的拼接方式：

• 方法1是比较传统的用法，在另一个针对数据操作的pandas库中对应的为concat ，即连接

• 方法2则是另一种快捷方式，其中h应该是horizontal 意思，v 应该是vertical

• 方法3则又可以分两类，其中第一类是第二类的缩写，也是我比较喜欢的用法，因为最简便。

• 方法4是与内置list比较同，使用要注意轴的设定

Numpy中数组的行列交换

导入库，赋值t

In [1]:import numpy as np
In [2]:t = t = np.arange(12,24).reshape(3,4)
Out[2]: 
array([[12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])

• 1、行交换

In [15]:t[[1,2],:] = t[[2,1],:] # 第2行和第3行交换
In [16]:t
Out[16]: 
array([[12, 13, 14, 15],
       [20, 21, 22, 23], #  第3行已换到第2行
       [16, 17, 18, 19]]) #  第2行已换到第3行

2、列交换

In [17]:t[:,[0,2]] = t[:,[2,0]] # 第1列和第3列交换
In [18]:t
Out[18]: 
array([[14, 13, 12, 15],
       [22, 21, 20, 23], 
       [18, 17, 16, 19]])

Numpy中的nan和inf

nan定义：

nan(NAN,Nan):not a number表示不是一个数字

nan的数据类型为float

出现nan的情况

• 当我们读取本地的文件为float的时候，如果有缺失，就会出现nan。
• 0/0的值也是nan
• 其他一些不合适的计算（例如无穷大inf减去无穷大）

nan的注意点

# 1、两个nan是不相等的
a = (np.nan == np.nan) # False

# 2、np.nan != np.nan
a = (np.nan !=  np.nan) # True

# 3、利用以上的特性，判断数组中nan的个数
np.count_nonzero(t1) # 方法返回的是t1数组中不为0的元素个数
np.count_nonzero(t1 != t1) # t1中的元素只有为nan的时候才不相等，所以方法可以返回t1中nan的个数，t1 != t2 实质上返回了一个布尔型数组，该数组只在nan处为True（非零），其他位置全部为False。

# 4、通过np.isnan()来判断数组中的nan
t[np.isnan(t)] = 0 # np.isnan()返回的是一个布尔类型的数组，与t != t返回的数组相同，由于numpy数组支持布尔索引，因为此行代码将布尔数组中为True的位置，也就是nan所在的位置全部修改为0
np.count_nonzero(np.isnan(t1)) # 返回的也就是t1中nan的个数，与3中的原理类似

# 5、nan与任何值计算都为nan
np.sum(t1) # 若t1数组中含有nan元素，则返回值为nan

我们一般将缺失的数值（nan）替换为均值（中值）或者是直接删除有缺失值的那一行

import numpy as np


def fill_ndarray(t1):
    for i in range(t1.shape[1]):
        temp_col = t1[:, i]  # 当前这一列
        nan_num = np.count_nonzero(temp_col != temp_col)  # 计算出这一列有多少nan
        if nan_num != 0:  # 如果不为0，说明当前这一列中有nan
            temp_not_nan_col = temp_col[temp_col == temp_col]  # 当前一列不为nan的array
            temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean()  # 将本列中不为nan的元素求出来的均值赋给本列中的nan
    return t1


if __name__ == '__main__':
    t1 = np.arange(12).reshape(3, 4).astype("float")
    t1[1, 2:] = np.nan
    t1 = fill_ndarray(t1)
    print(t1)

inf定义

inf(-inf,inf):infinity inf表示正无穷，-inf表示负无穷

inf的数据类型为float

出现inf的情况

• 一个数字除以0（python中会直接报错，而numpy中是一个inf或 -inf）

Numpy中常用的统计函数

# 所有函数默认返回多维数组的全部统计结果，如果指定axis则返回一个当前轴上的结果

t1.sum(axis=None) # 求和 默认计算出所有元素的总和
t1.mean(axis = 0)  # 均值 可以算出每一行的均值
np.median(t1, axis=None) # 中值 计算出t1所有元素的中位数
np.median(t1, axis=0) # 计算出每一行元素的中位数
t1.max(axis=None) # 最大值 默认计算出所有元素的最大值
t1.min(axis=None) # 最小值 默认计算出所有元素的最小值
np.ptp(t, axis=None) # 极差 默认计算出所有元素的最大值和最小值的差
t1.std(axis=None) # 标准差 默认返回所有元素的标准差

Numpy中一些好用的方法

• 获取最大最小值的位置
  • np.argmax(t, axis=0)
  • np.argmin(t, axis=1)
• 创建一个全为0的数组：np.zeros((3, 4)) 元素类型为float64
• 创建一个全为1的数组：np.ones((3, 4)) 元素类型为float64
• 创建一个对角线全为1的正方形数组（方阵）：np.eye(3) 元素类型为float64

Numpy中生成随机数

参数	解释
np.random.rand(d0,d1,…dn)	创建d0-dn维度的均匀分布的随机数数组，浮点数 ，范围从 0-1
np.random.randn(d0,d1,…dn)	创建d0-dn维度的标准正态分布的随机数，浮点数，平均数0，标准差1
np.random.randint(low,high,(shape))	从给定的上下限范围选取随机数整数 ，范围是能取到low-(high-1)，形状是shape
np.random.uniform(low,high,(size))	产生具有均匀分布的数组，low起始值，high结束值，size形状
np.random.normal(loc,scale,(size))	从指定正态分布中随机抽取样本，分布中心是loc（概率分布的均值 ），标准差为scale，形状是size
np.random.seed(s)	随机数种子，s是给定的种子值。因为计算机生成的是伪随机数，所以通过设定相同的的随机数种子，可以每次生成相同的随机数。

Numpy的注意点copy和view

• a=b 完全不复制，a和b相互影响
• a = b[:]，视图的操作，一种切片，会创建新的对象a，但是a的数据完全由b保管 ，他们两个的数据变化是一致的
• a = b.copy()，复制，a和b互不影响

参考博文

numpy中数组的拼接