NumPy(1)

于 2024-10-22 18:33:12 发布
阅读量930 收藏 15
点赞数 25
分类专栏： python语法及三大库 文章标签： numpy python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_70019265/article/details/143163442
版权

目录

1、数组相加

2、nditer()函数

3、flat()函数

4、flatten()

5、 raval()

6、transpose()

7、改变数组维度

8、数组连接

9、数据分割

10、resize()

11、insert()

12、delete()

13、argwhere()

14、unique()

15、ptp()

16、mean()

17、average()

18、var()

1、数组相加

import numpy as np

arr01 = np.array([[1, 2, 3],[4, 5, 6]])
arr02 = np.array([10, 20, 30])
#将arr02扩展为(2,3)形状，并将加到对应元素
arr03 = arr01 + arr02
print(arr03)

'''
运行结果
[[11 22 33]
 [14 25 36]]
'''

2、nditer()函数

#nditer：用于快速遍历多维数组的元素
# oeder：指定数组的遍历顺序
# flags：指定遍历的细节
# op_dtypes：指定遍历的元素的数据类型
def arr_nditer():
    arr = np.array([[1, 2, 3],[4, 5, 6]])
    for i in np.nditer(arr,order = "C"):
        print(i, end = " ")
    print()
    
    for j in np.nditer(arr,order = "F"):
        print(j, end = " ")
    print()
    
    for k in arr:
        print(k)
    
if __name__ == "__main__":
    arr_nditer()

3、flat()函数

# import numpy as np

# arr.flat：返回一维数组迭代器，按行遍历
def arr_flat():
    arr = np.arange(1,11).reshape(2,5)
    for i in arr.flat:
        print(i, end = " ")
        
if __name__ == "__main__":
    arr_flat()

4、flatten()

# import numpy as np

# arr.flatten()：返回一个新的一维数组，不影响原数组的形状
# order：C为行优先，F为列优先
def arr_flatten():
    arr = np.arange(1,11).reshape(2,5)
    print(arr.flatten(order="F"))
if __name__ == "__main__":
    arr_flatten()

参数

order: 指定数组的展开顺序。

  • 'C'：按行优先顺序展开（默认）。

  • 'F'：按列优先顺序展开。

  • 'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。

  • 'K'：按元素在内存中的顺序展开。

 

5、 raval()

# import numpy as np

# arr.raval()：  当修改raval返回的数组中的元素时，原数组也会发生变化
# arr.flatten()：当修改flatten返回的数组中的元素时，原数组不会发生变化
def arr_raval():
    arr = np.arange(1,11).reshape(2,5)
    arr01 = arr.ravel()
    print(arr01)
    print()
    
    arr[-1] = 10
    print(arr)
    print()
    
    arr01[-1] = 20
    print(arr)
    
    
if __name__ == "__main__":
    arr_raval()

参数

order: 指定数组的展开顺序。

  • 'C'：按行优先顺序展开（默认）。

  • 'F'：按列优先顺序展开。

  • 'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。

  • 'K'：按元素在内存中的顺序展开。

6、transpose()

函数名称说明
transpose将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2)
ndarray.T与 transpose 方法相同
# import numpy as np

# transpose()：返回原数组的转置
def transpose():
    arr = np.arange(1,7).reshape(2,3)
    print(arr)
    print()
    
    arr01 = arr.transpose()
    print(arr01)
    print()
    
    arr02 = arr.T
    print(arr02)
if __name__ == "__main__":
    transpose()

7、改变数组维度

函数名称参数说明
expand_dims(arr, axis)arr：输入数组 axis：新轴插入的位置在指定位置插入新的轴(相对于结果数组而言)，从而扩展数组的维度
squeeze(arr, axis)arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项删除数组中维度为 1 的项
# import numpy as np

#expand_dims()：在指定axis轴扩展数组的维度
#    squeeze()：按指定的axis轴降低数组的维度，前提是数组维度为1
#         axis：指定交换的轴
def axis_dims():
    arr = np.arange(1,7).reshape(2,3)
    print(arr)
    print()
    
    arr01 = np.expand_dims(arr, axis = 0)
    print(arr01)
    print()
    
    arr2 = np.arange(1,7).reshape(1,6)
    print(arr2)
    arr3 = np.squeeze(arr2, axis = 0)
    print(arr3)
    print()
    
if __name__ == "__main__":
    axis_dims()

8、数组连接

函数名称参数说明
hstack(tup)tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组按水平顺序堆叠序列中数组（列方向）
vstack(tup)tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组按垂直方向堆叠序列中数组（行方向）

hstack函数要求堆叠的数组在垂直方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。

hstack() 要求堆叠的数组在垂直方向（行）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。

vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。

#import numpy as np

# 数组连接
def arr_tup():
    arr_one = np.arange(1, 7).reshape(2, 3)
    arr_two = np.arange(7, 15).reshape(2, 4)

    # 水平连接数组
    re_one = np.hstack((arr_one, arr_two))
    print(re_one)
    print()
    
    # 垂直连接数组
    arr_three = np.arange(7, 19).reshape(4, 3)  
    print(arr_three)
    print()
    re_two = np.vstack((arr_one, arr_three))
    print(re_two)

if __name__ == "__main__":
    arr_tup()

9、数据分割

函数名称参数说明
hsplit(ary, indices_or_sections)ary：原数组 indices_or_sections：按列分割的索引位置将一个数组水平分割为多个子数组（按列）
vsplit(ary, indices_or_sections)ary：原数组 indices_or_sections：按列分割的索引位置将一个数组垂直分割为多个子数组（按行）
# import numpy as np

# 数组分割
# hsplit：水平分割，不包含指定的列值
# vsplit：垂直分割，不包含指定的行值
def arr_split():
    arr = np.arange(1, 25).reshape(4, 6)
    print(arr)
    print()
    
    re_one = np.hsplit(arr, [2,3,4])
    print(re_one)
    print()
    
    re_two = np.vsplit(arr, 2)
    print(re_two)

if __name__ == "__main__":
    arr_split()

10、resize()

函数名称参数说明
resize(a, new_shape)a：操作的数组 new_shape：返回的数组的形状，如果元素数量不够，重复数组元素来填充新的形状返回指定形状的新数组
# import numpy as np

# resize()：修改数组的形状，若数组中元素数量不足，这从原数组的开始位置添加到新数组中，
def arr_resize():
    arr = (1, 2, 3, 4, 5)
    arr = np.resize(arr, (2, 3))
    print(arr)
    
if __name__ == "__main__":
    arr_resize()

11、insert()

函数名称参数说明
insert(arr, obj, values, axis)arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反沿规定的轴将元素值插入到指定的元素前
# import numpy as np

# insert()：在指定位置插入元素
def arr_insert():
    arr = np.arange(6).reshape(2, 3)
    arr1 = np.insert(arr, 1, [6])
    print(arr1)
    print()
    
    arr2 = np.insert(arr, 1, [6], axis=0)
    print(arr2)
    print()
    
    arr3 = np.insert(arr, 1, [6], axis=1)
    print(arr3)
    
if __name__ == "__main__":
    arr_insert()

12、delete()

函数名称参数说明
delete(arr, obj, axis)arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反删掉某个轴上的子数组，并返回删除后的新数组
# import numpy as np
# delete()：删除指定位置的元素
# axis：指定删除的轴,0为行，1为列
def arr_delete():
    arr = np.arange(6).reshape(2, 3)
    print(arr)
    print()
    arr1 = np.delete(arr, 0)
    print(arr1)
    
if __name__ == "__main__":
    arr_delete()

13、argwhere()

返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标

#argwhere()：返回数组中非0元素的索引
def argwhere():
    arr = np.arange(10).reshape(2, 5)
    print(np.argwhere(arr))
    print()
if __name__ == "__main__":
    argwhere()

14、unique()

# import numpy as np

# unique()：返回数组中不重复的元素
# return_index：返回不重复元素的索引
# return_inverse：返回原数组中元素在unique后的对应下标
# return_counts：返回每个唯一元素在原数组中的出现次数
def arr_unique():
    arr = np.array([1, 2,2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 6])
    arr1, indices1 = np.unique(arr,return_index = True)
    print(arr1)
    print(indices1)
    print()
    
    arr2,indices2 = np.unique(arr, return_inverse = True)
    print(arr2)
    print(indices2)
    print()
    
    arr3,indices3 = np.unique(arr, return_counts = True)
    print(arr3)
    print(indices3)
    print()
    
    arr4 = np.array([[1,2],[2,3],[1,4],[5,6]])
    arr4, indices4 = np.unique(arr4, return_index=True)
    print(arr4)
    
if __name__ == "__main__":
    arr_unique()

15、ptp()

# import numpy as np

# median()：安装数值从大到小排列后,返回排列后数组元素的中位数
def arr_median():
    arr = np.array([[1, 3, 5, 7], [2, 4, 6, 8]])
    #不指定axis时，返回数组中所有元素排列后的中位数
    print(np.median(arr))
    print(np.median(arr, axis=0))
    print(np.median(arr, axis=1))

if __name__ == "__main__":
    arr_median()

16、mean()

# import numpy as np

# mean()：返回数组中元素的算数平均值
def arr_mean():
    arr = np.array([[1, 3, 5], [2, 4, 6]])
    #不指定axis时，返回数组中所有元素的算数平均值
    print(np.mean(arr))
    #指定axis时，返回数组中指定轴上元素的平均值
    #当axis=0时，返回每一列元素的平均值
    print(np.mean(arr, axis=0))
    #当axis=1时，返回每一行的元素平均值
    print(np.mean(arr, axis=1))
    
if __name__ == "__main__":
    arr_mean()

17、average()

加权平均值是将数组中各数值乘以相应的权数，然后再对权重值求总和，最后以权重的总和除以总的单位数（即因子个数）；根据在数组中给出的权重，计算数组元素的加权平均值。该函数可以接受一个轴参数 axis，如果未指定，则数组被展开为一维数组。

加权平均值=\dfrac{\sum _{i=1}^n(x_i\cdot w_i)}{\sum_{i=1}^nw_i}

其中 xi是数组中的元素，wi是对应的权重。

如果所有元素的权重之和等于1，则表示为数学中的期望值。

# import numpy as np

# average()：返回数组中元素的加权平均值
def arr_average():
    arr = np.arange(1, 5)
    #指定权重时
    weights = np.array([0.1, 0.2, 0.3, 0.4])
    #返回加权平均值
    print(np.average(arr,weights=weights))
    
if __name__ == "__main__":
    arr_average()

18、var()

在 NumPy 中，计算方差时使用的是统计学中的方差公式，而不是概率论中的方差公式，主要是因为 NumPy 的设计目标是处理实际数据集，而不是概率分布。

np.var 函数默认计算的是总体方差（Population Variance），而不是样本方差（Sample Variance）。

总体方差：

对于一个总体数据集 X={x1,x2,…,xN}，总体方差的计算公式为：

其中：

  • N是总体数据点的总数。

  • μ是总体的均值。

# import numpy as np

# var()：返回数组中元素的方差
def arr_var():
    arr = np.array([1, 2, 3, 4, 5])
    #不指定ddof时，返回总体方差(默认不指定)
    print(np.var(arr))
    #指定ddof=1时，返回样本方差
    print(np.var(arr, ddof=1))
    
    #不指定ddof时，返回标准方差
    print(np.std(arr))
    #指定ddof=1时，返回标准方差
    print(np.std(arr, ddof=1))
    
    arr = np.array([[1, 2], [3, 4]])
    #不指定axis时，返回数组中所有元素的方差
    print(np.var(arr))
    #指定axis时，返回数组中指定轴上元素的方差
    #当axis=0时，返回每一列元素的方差
    print(np.var(arr, axis=0))
    #当axis=1时，返回每一行的元素方差
    print(np.var(arr, axis=1))

if __name__ == "__main__":
    arr_var()

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值