Python——Numpy数组的介绍

1 Numpy中的数组

1.数组和基本语法中的列表很相似,列表中的元素=可以是任意类型,但数组中的元素类型是统一的,如果不统一页会强制统一,优先级[str > float >int]
2.列表如果是二维的,内层列表元素的个数可以不一致,但是数组中的内层元素个数必须是一致的


import numpy as np 
t1=[[19,12,11],[11,23],[23,34,44,554,45]]
t1
[[19, 12, 11], [11, 23], [23, 34, 44, 554, 45]]
t2=np.array(t1)
t2
:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.
  t2=np.array(t1)





array([list([19, 12, 11]), list([11, 23]), list([23, 34, 44, 554, 45])],
      dtype=object)
t3=[[1,2,3],[3,4,5],[6,7,8]]
t4=np.array(t3)
t4
array([[1, 2, 3],
       [3, 4, 5],
       [6, 7, 8]])
# 产生随机的数组
# numpy 把 random 特进行了封装
# tab 补齐代码
# shift + tab 查看功能的帮助文档
# np.random.randint(low,high,size)
'''
low 区间最小值
high 区间最大值[不包含]
size 产生随机的个数
    如果是一个整数就代表产生的是一位数组 ,size 代表了数组中元素的个数
    如果是一个二元组,元组中有两个值(M,N)代表产生的是一个二维数组,大数组中包含M个小数组,每个小数组中包含N个元素
        小数组代表行,小数组中的元素代表列
        也可以解读成生成一个M行N列的数组
'''
t1=np.random.randint(1,100,size=10)
t1
array([35, 85, 97, 48, 29, 44, 55, 54,  6, 74])
t2=np.random.randint(1,100,size=(3,4))
t2
array([[99, 62, 19, 64],
       [98,  3, 21, 26],
       [51, 27, 56, 40]])

2数组中元素的获取

通过下标获取相应的数据,跟列表是一样的

添加数据的时候,会给每个位置设置一个编号【下标】,有两种形式

1.从左向右 ,称为正向索引,从0到长度-1
2.从右向左 ,称为负向索引,从长度-1到0

2.1一维数组元素的获取

arr5 = np.random.randint(10, 100, size=15)
arr5
array([91, 60, 50, 82, 47, 65, 94, 77, 12, 76, 86, 28, 42, 54, 32])
arr5[0] # 获取下标为0的元素
91
arr5[-1] # 获取下标为-1 的元素
32
# 切片 提取子序列
"""
[起始下标:结束下标:步长]

步长为正数  代表的是正向切片。从左向右切片,注意 起始下标定位的位置要比结束下标的位置偏左
步长为负数  代表的是负向切片。从右向左切片,注意 起始下标定位的位置要比结束下标的位置偏右

:步长 可以省略  省略的时候为1
"""
arr5[5:10]  # 结束下标是不包含的
array([65, 94, 77, 12, 76])
arr5[5:10:2] # 获取下标从5开始到10[不包含10],且步长为2的元素
array([65, 77, 76])
# 起始位置也可以省略
"""
步长为正数  从最左边开始
步长为负数  从最右边开始
"""
'\n步长为正数  从最左边开始\n步长为负数  从最右边开始\n'
arr5[:7] # 获取从左边第一个元素开始到下标为7【不包含7】的所有元素
array([91, 60, 50, 82, 47, 65, 94])
arr5[:-7:-1] # 获取从右边第一个元素开始到下标为-7【不包含-7】的所有元素
array([32, 54, 42, 28, 86, 76])
# 结束位置也可以省略
"""
步长为正数  到最右边结束[包含最右边]
步长为负数  到最左边结束[包含最左边]
"""
arr5[7:] # 获取从下标为7的元素开始到最后一位元素
array([77, 12, 76, 86, 28, 42, 54, 32])
arr5[-7::-1] # 获取下标从-7开始步长为-1的所有元素
array([12, 77, 94, 65, 47, 82, 50, 60, 91])
# 全部省略【步长默认为1】
arr5[:]
array([91, 60, 50, 82, 47, 65, 94, 77, 12, 76, 86, 28, 42, 54, 32])
arr5[::-1] # 获取所有元素步长为-1【相当于反转】
array([32, 54, 42, 28, 86, 76, 12, 77, 94, 65, 47, 82, 50, 60, 91])

2.2 二维数组元素的获取

arr6 = np.random.randint(10, 100, size=(4, 5))
arr6
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61],
       [30, 49, 35, 94, 22],
       [55, 11, 96, 89, 75]])
# 大数组中嵌套的是小数组  小数组中才是具体的数据元素
arr6[0]
array([81, 67, 62, 46, 67])
arr6[0][0] # 获取第一行第一列的元素
81
# 定位元素的时候  需要先定位小数组  在定位数据中元素
# 上面的格式 在数组中有一个独特的表达方法  数组对象[行下标, 列下标]
arr6[0, 0] # 获取第一行第一列的元素
81
arr6[-1, -1] # 获取最后一行,最后一列的元素
75
arr6[1, -1] # 获取第二行,最后一列的元素
61
array=([84, 52, 42, 16, 98])
# 切片  比一维的情况 多出行切片或者列切片
# 同理 定位列  先定位行
# 行切片 
arr6[:2] # 获取前两行的元素
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61]])
arr6[::-1]  # 行反转
array([[55, 11, 96, 89, 75],
       [30, 49, 35, 94, 22],
       [43, 10, 21, 60, 61],
       [81, 67, 62, 46, 67]])
arr6[:] # 获取所有行
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61],
       [30, 49, 35, 94, 22],
       [55, 11, 96, 89, 75]])
    # 切列   
# 数组对象[行切片, 列切片]
arr6[:, 0]  #  --- 第一列
array([81, 43, 30, 55])
arr6[:, -1] # 获取所有行,最后一列元素
array([67, 61, 22, 75])
arr6[:, :2] # 获取所有行,前两列的元素
array([[81, 67],
       [43, 10],
       [30, 49],
       [55, 11]])
arr6[:, ::-1] # 获取所有行,且步长为-1的所有列的元素【相当于反转列】
array([[67, 46, 62, 67, 81],
       [61, 60, 21, 10, 43],
       [22, 94, 35, 49, 30],
       [75, 89, 96, 11, 55]])
arr6[:2, :2] # 获取前两行前两列的元素
array([[81, 67],
       [43, 10]])
arr6
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61],
       [30, 49, 35, 94, 22],
       [55, 11, 96, 89, 75]])
arr6[::-1,::-1] # 反转所有行和列
array([[75, 89, 96, 11, 55],
       [22, 94, 35, 49, 30],
       [61, 60, 21, 10, 43],
       [67, 46, 62, 67, 81]])

2.3 花式索引

数组中特有的

arr5 = np.random.randint(10, 100, size=15)
arr5
array([77, 35, 55, 83, 98, 99, 66, 60, 28, 93, 89, 32, 54, 69, 41])
# 花式索引可以传递一个列表  列表里面存放的是下标  下标是什么顺序 数据值展示的就是什么顺序
arr5[[0, -1, 2, 1, 4, 3]]
array([77, 41, 55, 35, 98, 83])
arr5[5:10]  # 结束下标是不包含的
array([99, 66, 60, 28, 93])
# 奇数下标位置的
arr5[1::2]
array([35, 83, 99, 60, 93, 32, 69])
# 获取下标 1 5 6 8 9
arr5[[1, 5, 6, 8, 9]]
array([35, 99, 66, 28, 93])
arr6
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61],
       [30, 49, 35, 94, 22],
       [55, 11, 96, 89, 75]])
# 提取前2行
arr6[:2]
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61]])
# 提取1 3 4 行
arr6[[0, 2, 3]]
array([[81, 67, 62, 46, 67],
       [30, 49, 35, 94, 22],
       [55, 11, 96, 89, 75]])
# 提取 1 2 4列
arr6[:, [0, 1, 3]]
array([[81, 67, 46],
       [43, 10, 60],
       [30, 49, 94],
       [55, 11, 89]])
# 提取 1 3 4 行的 1 2 4列  === 想要的结果是三行三列
# arr6[[0, 2, 3], [0, 1, 3]]  # 花式索引拿到的结果 array([85, 51, 16]) (0,0)  (2, 1)  (3, 3)

# 直接拿拿不到 需要分开来拿
# 先定位行,再定位列
rows = arr6[[0, 2, 3]]
rows[:, [0, 1, 3]]
array([[81, 67, 46],
       [30, 49, 94],
       [55, 11, 89]])
# 行的顺序转换一下  1-3  2-4 4-1  3-2
arr6[[3, 2, 0, 1]]
array([[55, 11, 96, 89, 75],
       [30, 49, 35, 94, 22],
       [81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61]])

2.3 布尔索引

生成布尔序列[一个容器中全部都是布尔值], 为True对应的位置代表保留, 为False对应的位置代表舍弃

arr7 = arr5[:8]
arr7
array([77, 35, 55, 83, 98, 99, 66, 60])
arr7[[True, False, True, True, False, True, False, True]]  # 布尔序列的个数要和数组的个数一致
array([77, 55, 83, 99, 60])
# 布尔序列是用来筛选的
# 数组的奇妙之处: 矢量运算 【避免了复杂的循环操作  将数组中每个数据和指定的数据进行运算】

nums = [12, 34, 56, 78]
# 让每个数据乘以10  对与列表来说完成的是重复的操作 
# nums * 10
[ele * 10 for ele in nums]
[120, 340, 560, 780]
arr8 = np.array(nums)
arr8 * 10
array([120, 340, 560, 780])

这个本质是广播机制

  1. N行M列 与 一个常量[一个数值]
    这个数值会被广播成N行M列
  2. N行M列 与 一行M列
    一行M列会被广播成N行M列
  3. N行M列 与 N行一列
    N行一列 会被广播成N行M列
  4. N行一列与一行M列
    N行一列广播成N行M列
    一行M列广播成N行M列
arr8 * np.array([10, 10, 10, 10])  # arr8 * 10
array([120, 340, 560, 780])
arr6  # 4行5列  
array([[81, 67, 62, 46, 67],
       [43, 10, 21, 60, 61],
       [30, 49, 35, 94, 22],
       [55, 11, 96, 89, 75]])
arr9 = np.array([1, 2, 3, 4, 5])
arr9
array([1, 2, 3, 4, 5])
"""
array([[1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5]])
"""
arr6 + arr9
array([[82, 69, 65, 50, 72],
       [44, 12, 24, 64, 66],
       [31, 51, 38, 98, 27],
       [56, 13, 99, 93, 80]])
arr10 = np.random.randint(1, 5, size=(4, 1))
arr10
array([[2],
       [2],
       [3],
       [4]])
"""
array([[3, 3, 3, 3, 3],
       [3, 3, 3, 3, 3],
       [3, 3, 3, 3, 3],
       [3, 3, 3, 3, 3]])
"""
arr6 + arr10
array([[ 83,  69,  64,  48,  69],
       [ 45,  12,  23,  62,  63],
       [ 33,  52,  38,  97,  25],
       [ 59,  15, 100,  93,  79]])
arr9
array([1, 2, 3, 4, 5])
arr10
array([[2],
       [2],
       [3],
       [4]])
"""
array([[1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5]])
array([[3, 3, 3, 3, 3],
       [3, 3, 3, 3, 3],
       [3, 3, 3, 3, 3],
       [3, 3, 3, 3, 3]])
"""
arr9 + arr10
array([[3, 4, 5, 6, 7],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8],
       [5, 6, 7, 8, 9]])
# 布尔运算
arr5
array([77, 35, 55, 83, 98, 99, 66, 60, 28, 93, 89, 32, 54, 69, 41])
# 找60及其以上的数据
np.array([ele for ele in arr5 if ele >= 60])
array([77, 83, 98, 99, 66, 60, 93, 89, 69])
# 将数据和60进行对比
arr5[arr5>=60]
array([77, 83, 98, 99, 66, 60, 93, 89, 69])
arr6 = np.random.randint(10, 100, size=(4, 5))
## 在二维中使用布尔序列
# 涉及到行方向【竖向】和列方向【横向】
"""
行维度进行筛选是  布尔值个数要和行数一致
进行列维度筛选时  布尔值个数要和列数一致
"""
arr6  # 4行5列
array([[90, 57, 53, 59, 67],
       [12, 28, 67, 85, 92],
       [53, 54, 21, 99, 71],
       [15, 81, 58, 56, 46]])
arr6[[True, False, True, True]]
array([[90, 57, 53, 59, 67],
       [53, 54, 21, 99, 71],
       [15, 81, 58, 56, 46]])
# 布尔序列获取12 45列
arr6[:, [True, True, False, True, True]]
array([[90, 57, 59, 67],
       [12, 28, 85, 92],
       [53, 54, 99, 71],
       [15, 81, 56, 46]])
# 获取一行数据中的值都在50以上的数据行
res = arr6 > 50
res
array([[ True,  True,  True,  True,  True],
       [False, False,  True,  True,  True],
       [ True,  True, False,  True,  True],
       [False,  True,  True,  True, False]])
要整合数据

np.all(数组) 数组中所有的数据全部参与判定

数据中全部都是成立的结果才为True

np.any(数组) 数组中所有的数据全部参与判定

数据中只要有一个成立结果就是True
np.all(res)
False
np.any(res)
True
# 需求中 需要判断的是行或者列
# np.all(数组, axis轴向)
# axis有两个值 0和1   
"""
二维数组 有两个方向轴  一个是行 一个是列
定位数据的时候是先行后列  按照这个顺序 所以第一轴向就是行为0  第二轴向是列为1
"""

np.all(res, axis=1)
array([ True, False, False, False])
arr6[np.all(res, axis=1)]
array([[90, 57, 53, 59, 67]])
arr6
array([[90, 57, 53, 59, 67],
       [12, 28, 67, 85, 92],
       [53, 54, 21, 99, 71],
       [15, 81, 58, 56, 46]])
# 有任意一个值在50以上的列 
# 注意:取列先取行
arr6[:,np.any(res, axis=0)]
array([[90, 57, 53, 59, 67],
       [12, 28, 67, 85, 92],
       [53, 54, 21, 99, 71],
       [15, 81, 58, 56, 46]])

2.4 Numpy的相关运算

算术运算

加+

减-

乘*

除/

整除//

取余%

幂数**

arr5
array([77, 35, 55, 83, 98, 99, 66, 60, 28, 93, 89, 32, 54, 69, 41])
arr5 + 10
array([ 87,  45,  65,  93, 108, 109,  76,  70,  38, 103,  99,  42,  64,
        79,  51])
arr5 - 20
array([57, 15, 35, 63, 78, 79, 46, 40,  8, 73, 69, 12, 34, 49, 21])
arr5 * 5
array([385, 175, 275, 415, 490, 495, 330, 300, 140, 465, 445, 160, 270,
       345, 205])
arr5 / 10
array([7.7, 3.5, 5.5, 8.3, 9.8, 9.9, 6.6, 6. , 2.8, 9.3, 8.9, 3.2, 5.4,
       6.9, 4.1])
arr5 // 10
array([7, 3, 5, 8, 9, 9, 6, 6, 2, 9, 8, 3, 5, 6, 4], dtype=int32)
arr5 % 3
array([2, 2, 1, 2, 2, 0, 0, 0, 1, 0, 2, 2, 0, 0, 2], dtype=int32)
arr5 ** (1/2)
array([8.77496439, 5.91607978, 7.41619849, 9.11043358, 9.89949494,
       9.94987437, 8.1240384 , 7.74596669, 5.29150262, 9.64365076,
       9.43398113, 5.65685425, 7.34846923, 8.30662386, 6.40312424])

2.4.1 比较运算

大于 >

小于 <

大于或者等于 >=

小于或者等于 <=

是否相等 ==

是否不等 !=

arr5 > 70
array([ True, False, False,  True,  True,  True, False, False, False,
        True,  True, False, False, False, False])
arr5 >= 60
array([ True, False, False,  True,  True,  True,  True,  True, False,
        True,  True, False, False,  True, False])
arr5 == 29
array([False, False, False, False, False, False, False, False, False,
       False, False, False, False, False, False])

2.4.2 逻辑运算

注意在这里不是and 、or/ not了,因为只是针对于一个布尔值的运算 , True and True 或者 True or False 或者 not False,这里的数组运算是需要将数组中每一个值都参与逻辑运算,这里使用的是

&(逻辑与)

|(逻辑或)

~(逻辑非)

注意: 数组中的逻辑运算符优先级别高于 比较运算符

arr5
array([77, 35, 55, 83, 98, 99, 66, 60, 28, 93, 89, 32, 54, 69, 41])
# 找到30-40之间的数据
arr5 >= 30
array([ True,  True,  True,  True,  True,  True,  True,  True, False,
        True,  True,  True,  True,  True,  True])
arr5 <= 40
array([False,  True, False, False, False, False, False, False,  True,
       False, False,  True, False, False, False])
(arr5 >= 30) & (arr5 <= 40)
array([False,  True, False, False, False, False, False, False, False,
       False, False,  True, False, False, False])
arr5[(arr5 >= 30) & (arr5 <= 40)]
array([35, 32])

2.4.3 求和

数组.sum()

arr5.sum()
979
arr6
array([[90, 57, 53, 59, 67],
       [12, 28, 67, 85, 92],
       [53, 54, 21, 99, 71],
       [15, 81, 58, 56, 46]])
arr6.sum()  # 二维的数据:所有的数据参与求和
1164
# 每一行的和 : 每列号都参与运算
arr6.sum(axis=1)
array([326, 284, 298, 256])
# 每一列的和: 每行号的值参与运算
arr6.sum(axis=0)
array([170, 220, 199, 299, 276])

2.4.4 其他

平均值 数组.mean

最大值 数组.max()

最小值 数组.min()

arr6.max()
99
arr6.max(axis=1)# 求每一行的最大值
array([90, 92, 99, 81])
arr6.mean()
58.2
arr6.mean(axis=0) # 求每一列的平均数
array([42.5 , 55.  , 49.75, 74.75, 69.  ])

你可能感兴趣的:(python,numpy,开发语言)