一个在Python中做科学计算的基础库,重在数值计算,也是大部分Python科学计算库的基础库,多用于在大型、多维数组上执行数值计算。
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.ndarray
a.dtype
来查看当前数组内部元素的数据类型a.astype()
传入目标数据类型参数,即可转换a中元素的数据类型类型 | 类型代码 | 说明 |
---|---|---|
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)也是可以进行运算的。
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阵列时的报错
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)
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]]) # 取到的值是第零行第零列和第二行第一列的值
索引到要修改的位置直接进行赋值,就可以实现数值的修改。
我们可以通过一个布尔数组来索引目标数组,以此找出与布尔数组中值为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]])
花式索引是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])
np.where(t<10,0,10)
将满足条件的数值修改为第二个参数值,不满足条件的数值修改为第三个参数值。
t.clip(10,18)
小于10的全部替换成10,大于18的全部替换成18,但是nan不会被替换。
接下来介绍我所知道的四种numpy数组的拼接方式:
concat
,即连接
h
应该是horizontal
意思,v
应该是vertical
导入库,赋值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]])
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]])
nan(NAN,Nan):not a number
表示不是一个数字
nan
的数据类型为float
float
的时候,如果有缺失,就会出现nan
。0/0
的值也是nan
inf
减去无穷大)# 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):infinity
inf表示正无穷,-inf表示负无穷
inf
的数据类型为float
# 所有函数默认返回多维数组的全部统计结果,如果指定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) # 标准差 默认返回所有元素的标准差
np.argmax(t, axis=0)
np.argmin(t, axis=1)
np.zeros((3, 4))
元素类型为float64np.ones((3, 4))
元素类型为float64np.eye(3)
元素类型为float64参数 | 解释 |
---|---|
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中数组的拼接