Python——Numpy数组的介绍

最新推荐文章于 2023-12-19 22:48:24 发布
最新推荐文章于 2023-12-19 22:48:24 发布
阅读量226 收藏
点赞数 3
文章标签： python numpy 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73622195/article/details/132823255
版权

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

<ipython-input-8-2eb6b2646586>: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.  ])
谪 语
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python numpy数组
大橙砸的博客
05-14 820
Python numpy数组 数组定义 使用List创建 In [1] : np.array([2, 3, 6, 7]) Out[l] : array([2, 3, 6, 7]) 创建均匀间隔的数组 arange(start, stop, step)的所有三个参数即起始值，结束值，步长都是可以用的 另外还有一个数据的dtype参数 In [2]：np.aran...
numpy函数------周东海
weixin_57121160的博客
04-24 838
import numpy as np a = np.dtype(np.int32) print(a) # 数据类型对象 b = np.dtype(np.float32) # b = np.array([1, 2, 3]) # b = np.dtype('i4') # 创建数组，指定数据类型 c = np.array([1, 2, 3], dtype=b) print(c) # 定义数据类型 dt = np.dtype([('age', np.int8)]) # 用dt数据类型创建数组 e = ...
python-numpy数组
wj1298250240的博客
11-24 337
python-numpy数组 NumPy Basics: Arrays and¶ # 优点： # NumPy是在⼀个连续的内存块中存储数据，独⽴于其他 # Python内置对象。 # NumPy可以在整个数组上执⾏复杂的计算， import numpy as np np.random.seed(12345) import matplotlib.pyplot as plt plt.rc('figur...
Python Numpy数组
chg2663776的博客
04-01 1337
Python Numpy数组
Python基础 - NumPy数组
只为龙舞的博客
04-22 3812
一、多维数组 Python提供的基础数据结构列表、元组等都是可以看做简单的一维数组，那么用到多维数组时该如何处理呢？因为当前的结构中的每个元素都是不限类型的，而每种结构也是一种类型，那么理所当然可以想到将基础数据结构嵌入到基础数据结构中得到多维数据结构： 二、NumPy NumPy是Python的一个扩展程序库，支持大量的为读书族与矩阵运算，并且针对数组运算提供了大量的数学函数库。...
Python学习笔记——Numpy数组的排序和搜索
12-21
在Python的科学计算库NumPy中，数组的排序和搜索是常见的操作，这对于数据分析和处理至关重要。本篇学习笔记将详细介绍NumPy中的`sort`和`argsort`函数，以及拓展的`where`函数。 首先，`sort`函数是NumPy提供的一...
Python实现图片切割拼接实验——numpy数组的脑洞玩法
12-21
这种玩法依赖于对图像数据的深入理解，特别是将图像数据转化为numpy数组进行操作。 首先，我们要了解图像与numpy数组的关系。图像本质上是一系列像素值的集合，每个像素点由红绿蓝（RGB）三个颜色通道的数值组成。...
基于Python中numpy数组的合并实例讲解
01-20
Python中numpy数组的合并有很多方法，如 – np.append() – np.concatenate() – np.stack() – np.hstack() – np.vstack() – np.dstack() 其中最泛用的是第一个和第二个。第一个可读性好，比较灵活，但是占...
Python数据分析应用：创建numpy数组.pptx
02-04
首先，我们来看最简单的创建numpy数组的方法——`array()`函数。这个函数允许你将已有的Python列表或元组转换为numpy数组。例如，创建一个包含整数的一维数组，你可以这样做： ```python import numpy as np arr = ...
Python 科学计算——numpy 篇
02-24
在Python的科学计算领域，numpy库扮演着至关重要的角色。它是Python进行高效数值计算的核心库，为处理大型多维数组和矩阵提供了丰富的功能。本篇文章将深入探讨numpy库中的主要概念，包括矩阵运算、ufunc（通用函数...
【Python基础】Python之Numpy数组
weixin_34200157的博客
12-29 219
Python之Numpy数组 把经常会用到的数组列在这里... 1. np.zeros() a1 = np.zeros(3) # array([0., 0., 0.]) a2 = np.zeros([2,3]) # array([[0., 0., 0.], # [0., 0., 0.]]) a3 = np.zeros((2, 2)) # array([[0., 0.], # [0., 0.]]) zeros创建的是全部为0的数组，zeros()里面填单个数字:一维数
python Numpy—— 数组array
蝉之洞
02-27 1410
知乎：CS231n课程笔记翻译：Python Numpy教程好书：《python科学计算》1.np.newaxis 用于增加数组的维度def test(): #增加新维度 a = np.array(np.random.randint(1,10,10)) # 一维数组 print(a, a.shape) print('-----------------') ...
python-numpy模块(数组操作)
qq_43273590的博客
02-23 724
list ：特殊的数组 数组和列表的区别: 数组: 存储的时同一种数据类型; list:容器， 可以存储任意数据类型; 1.Numpy简介： 什么是numpy？ NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库； 快速， 方便的科学计算基础库(主要时数值的计算， 多维数组的运算)。 轴...
Python之numpy数组篇（上）
申小兮和林小兮的博客宝
10-21 3076
Python之numpy数组及其运算，创建数组，测试数组元素接近度，修改数组元素值，数组与标量、数组的运算
Python之NumPy数组应用
踏雪无痕
07-10 876
&amp;amp;nbsp;## NumPy最重要的一个特点就是其N维数组对象（即ndarray），该对象是一个快速而灵活的大数据集容器。 NumPy最重要的一个特点就是其N维数组对象（即ndarray），该对象是一个快速而灵活的大数据集容器。¶ In&amp;amp;nbsp;[1]:ximport numpy as npdata = [2,4,1.2,34,0]# 基本类型数组array = np.array(data)pr...
理解numpy的rollaxis与swapaxes函数
qq_35810838的博客
11-21 623
现在再说rollaxis函数,这个函数有三个参数  numpy.rollaxis(arr, axis, start) arr：输入数组 axis：要向后滚动的轴，其它轴的相对位置不会改变 start：默认为零，表示完整的滚动。会滚动到特定位置 import numpy as np a = np.arange(8).reshape(2, 2, 2) print '原数组：' prin...
Python 多维数组详解（numpy）
最新发布
鱼丸丶粗面
12-19 3912
Python 多维数组详解（numpy）
Numpy数组规格及字段类型详解
weixin_43092663的博客
04-22 1156
本文详细介绍了numpy数组的规格和字段类型。其中数组规格包括数组的维度ndim、形状shape和大小size，字段类型介绍了dtype和astype的用法
python 数组格式转换
weixin_30832143的博客
08-19 819
格式转换 arr1 = [ {'name': 'jack', 'hobby': '西瓜'}, {'name': 'jack', 'hobby': '冬瓜'}, {'name': 'rose', 'hobby': '木瓜'}, {'name': 'rose', 'hobby': '甜瓜'}, {'name': 'jack', 'hob...
Python库——Numpy
09-11
Numpy是一个Python库，用于进行科学计算。它提供了一个强大的多维数组对象ndarray，并且包含了许多用于数组计算的函数和方法。通过Numpy，我们可以进行数组的创建、索引和切片操作，还可以进行矩阵运算和使用通用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值