当前位置：首页 > article >正文

NumPy学习Day18

article 2024/10/26 21:57:02

1.数据迭代

1.1 nditer

使用np.nditer(x,order=)遍历数组x中的元素

x为需要遍历的数组
order='c’时按照行优先遍历
order='f’时按照列优先遍历

1.2 flags参数

flags可以返回数组中元素的多维索引（类似矩阵的坐标）

multi_index: 返回每个元素的多维索引。
external_loop: 返回一维数组而不是单个元素，减少函数调用的次数，从而提高性能。

import numpy as np
def arr_nditer():
    arr = np.array([[1,2,3,4],[5,6,7,8]])
    print(arr)
    #order='c'表示按行遍历数组
    for x in np.nditer(arr,order='c'):
        print(x,end=' ')
    print(end='\n')
    #order='f'表示按列遍历数组
    for y in np.nditer(arr,order='f'):
        print(y,end=' ')
    print()
    #不写order表示默认按行遍历
    for z in np.nditer(arr):
        print(z)
    print()

    #flags可以返回数组元素的多维索引(相当于矩阵中的坐标点)
    #flags的参数是一个数组
    it = np.nditer(arr,flags=['multi_index'])
    for x in it:
        print(f'x:{x},multi_index:{it.multi_index}')

    #external_loop：遍历数组，返回一个一维的遍历结果数组
    for x in np.nditer(arr,flags=['external_loop'],order='f'):
        print(f'x:{x}')

    # 类似python列表遍历，如果是多维数组，将行作为整体
    for x in arr:
        print(x)

# arr_nditer()

1.3 op_flags 参数

op_flags 参数用于指定操作数的行为。

readonly: 只读操作数。
readwrite: 读写操作数。
writeonly: 只写操作数。

2.数组操作

2.1 数组变维

函数名称	函数介绍
reshape	在不改变数组元素的条件下，修改数组的形状
flat	返回是一个迭代器，可以用 for 循环遍历其中的每一个元素
flatten	以一维数组的形式返回一份数组的副本，对副本的操作不会影响到原数组
ravel	返回一个连续的扁平数组（即展开的一维数组），与 flatten不同，它返回的是数组视图（修改视图会影响原数组）

import numpy as np
def arr_flat():
        arr = np.arange(1,11).reshape(2,5)
        print(f'初始数组为:{arr}')
        # flat返回一维数组迭代器，按行遍历
        for x in arr.flat:
            print(x,end=' ')
        print()

        # flatten返回一个新的一维数组，不影响原数组的形状
        # 可以通过order设置按行或按列返回一维数组
        arr1 = arr.flatten(order='f')
        print(arr1)


        arr2 = arr.ravel()
        print(arr2)

        # 当修改由flatten返回的一维数组的元素时，不影响原数组中的元素
        # 当修改由ravel返回的一维数组的元素时，原数组的元素也会被影响
        # ravel方法返回的是元素组的视图
        arr1[-1] = 20
        print(arr,'----')
        arr2[-1] = 20
        print(arr,'!!!!!')

# arr_flat()

2.2 数组转置

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

#arr.T:数组转置
#np.transpose(arr):转置数组
def arr_transpose():
    arr = np.arange(1,7).reshape(2,3)
    arr1 = arr.T
    print(arr,'~~~~')
    print(arr1,'!!!!')
    print('-----')
    arr2 = np.transpose(arr)
    print(arr2)

# arr_transpose()

2.3 修改数组维度

多维数组（也称为 ndarray）的维度（或轴）是从外向内编号的。这意味着最外层的维度是轴0，然后是轴1，依此类推。

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

# np.expands_dims(arr,axis)：按照指定的axis轴拓展数组的维度
# np.squeeze(arr,axis)：按照指定的axis轴降低数组的维。前提：数组的最外层为1，否则报异常
def arr_dims():
    arr = np.arange(1,7)
    arr1 = np.expand_dims(arr,axis=0)
    print(arr1)

    arr2 = np.expand_dims(arr,1)
    print(arr2)


    arr3 = np.arange(1,7).reshape(2,3)
    arr4 =np.expand_dims(arr3,0)
    print(arr4)
    arr5 = np.expand_dims(arr3,1)
    print(arr5)

    arr6 = np.arange(1,7).reshape(1,6)
    print(arr6)
    arr7 = np.squeeze(arr6,0)
    print(arr7)

    # arr8 = np.squeeze(arr3,0)
    # print(arr8)
# arr_dims()

2.4 连接数组

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

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

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

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

#np.hstack(arr1,arr2):两个数组按列拼接，前提：行数一致
#np.vstack(arr1,arr2):两个数组按行拼接，前提：列数一致
def arr_concat():
    arr1 = np.arange(1,7).reshape(2,3)
    arr2 = np.arange(7,15).reshape(2,4)
    arr3 = np.hstack((arr1,arr2))
    print(arr3)

    arr4 = np.arange(7,13).reshape(2,3)
    arr5 = np.vstack((arr1,arr4))
    print(arr5)

# arr_concat()

2.5 分割数组

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

#np.hsplit(arr,indices):按照列切割，不包含指定列值
#np.vsplit(arr,indices):按照行切割，不包含指定行值
def arr_split():
    arr = np.arange(1,13).reshape(3,4)
    print(arr)
    result = np.hsplit(arr,[1,3])
    print(result)
    print(result[0])
    print(result[1])
    print(result[2])

    result1 = np.vsplit(arr,[1])
    print(result1)
    print(result1[0])
    print(result1[1])

# arr_split()

3.数组元素的增删改查

3.1 resize

np.resize(arr,new_shape(m,n)):改变数组的形状，如果原数组中的元素数量不够，则将原数组开始位置的元素依次添加到指定形状的数组中

3.2 append

np.append(arr,values,axis):将values追加到arr数组中

如果没有指定axis则将values追加到arr后面，然后返回一个一维数组
如果axis=0则按行追加到arr数组后
如果axis=1则按列追加到arr数组后

3.3 insert

np.insert(arr,indices,values,axis):在原数组指定的索引前(不包含索引值)插入values

如果不指定axis，则添加值之后不返回一维数组
如果axis=0，则按行添加
如果axis=1，则按列添加

3.4 delete

np.delete(arr,indices,axis):

根据指定的indices索引值删除元素
不指定axis，则返回一维数组
axis=0，按行删除
axis=1，按列删除

3.5 argwhere

np.argwhere(arr):返回数组中所有非0元素的下标

3.6 unique

np.unique:对数组元素去重

return_index=Ture:表示新数组元素在原数组中的索引位置
return_inverse=Ture:表示原数组元素在新数组中的索引位置
return_count=Ture:表示新数组中的元素在原数组中出现的次数

如果对多维数组进行去重，则先将多维数组转换为一维数组，然后去重，最后返回一个去重后的一维数组

#np.resize(arr,new_shape(m,n)):改变数组的形状，如果原数组中的元素数量不够，则将原数组开始位置的元素依次添加到指定形状的数组中
def arr_resize():
    arr = np.array([1,2,3,4,5])
    arr1 = np.resize(arr,(3,3))
    print(arr1)

# arr_resize()


#np.append(arr,values,axis):将values追加到arr数组中
#如果没有指定axis则将values追加到arr后面，然后返回一个一维数组
#如果axis=0则按行追加到arr数组后
#如果axis=1则按列追加到arr数组后
def arr_append():
    arr = np.arange(6).reshape(2,3)
    print(arr)
    arr1 = np.append(arr,[[0,0,0],[1,1,1]],None)
    print(arr1)
    arr2 = np.append(arr,[[0,0,0],[1,1,1]],0)
    print(arr2)
    arr3 = np.append(arr, [[0, 0, 0], [1, 1, 1]], 1)
    print(arr3)
# arr_append()



#np.insert(arr,indices,values,axis):在原数组指定的索引前(不包含索引值)插入values
#如果不指定axis，则添加值之后不返回一维数组
#如果axis=0，则按行添加
#如果axis=1，则按列添加
def arr_insert():
    arr = np.arange(6).reshape(2,3)
    arr1 = np.insert(arr,1,[99])
    print(arr1)
    arr2 = np.insert(arr,1,[99],0)
    print(arr2)
    arr3 = np.insert(arr,1,[99],1)
    print(arr3)
    arr4 = np.insert(arr,-1,[99],1)
    print(arr4)
# arr_insert()

#np.delete(arr,indices,axis):
#根据指定的indices索引值删除元素
#不指定axis，则返回一维数组
#axis=0，按行删除
#axis=1，按列删除
def arr_delete():
    #一维数组删除：直接根据索引删除对应位置元素
    arr = np.array([1,2,3,4,5,6])
    arr1 = np.delete(arr,(2,4))
    print(arr1)

    arr2 = np.arange(1,7).reshape(2,3)
    arr3 = np.delete(arr2,1,0)
    print(arr3)
    arr4 = np.delete(arr2,1,1)
    print(arr4)

# arr_delete()


#np.argwhere(arr):返回数组中所有非0元素的下标
def arr_argwhere():
    arr = np.arange(6).reshape(2,3)
    arr1 = np.argwhere(arr)
    print(arr1)

# arr_argwhere()

#np.unique:对数组元素去重
#return_index=Ture:表示新数组元素在原数组中的索引位置
#return_inverse=Ture:表示原数组元素在新数组中的索引位置
#return_count=Ture:表示新数组中的元素在原数组中出现的次数
def arr_unique():
    arr = np.array([1,2,2,3,3,3,4,4,4,4,5,5,5,5,5])
    arr1,indices1 = np.unique(arr,return_index=True)
    print(arr1)
    print(indices1)
    arr2,indices2 = np.unique(arr,return_inverse=True)
    print(arr2)
    print(indices2)
    arr3,indices3 =np.unique(arr,return_counts=True)
    print(arr3)
    print(indices3)

    #如果对多维数组进行去重，则先将多维数组转换为一维数组，然后去重，最后返回一个去重后的一维数组
    arr4 = np.array([[1,2],[2,3],[3,4]])
    arr5,indices5 = np.unique(arr4,return_index=True)
    print(arr5,'----')
    print(indices5,'---')
# arr_unique()

4. 统计函数

4.1 amin/amax

amin:求数组中最小值，axis=0时找每列中的最小值，axis=1时找每行中的最小值

amax:求数组中最大值，axis=0时找每列中的最大值，axis=1时找每行中的最大值

4.2 ptp

ptp:求数组中最大值和最小值的差，axis=0，求每列中最大值和最小值的差，axis=1，求每行中最大值和最小值的差

4.3 median

np.median(arr,axis):求中位数，即按照数值从大到小排列后中间的元素值，如果元素个数为偶数则中位数为中间两个元素值的平均值，如果元素个数为奇数则为元素本身

axis=0，找每列的中位数
axis=1，找每行的中位数
axis=None，将数组转为一维数组找中位数

4.4 mean

np.mean(arr,axis):求数组中的算术平均值

axis=None时将多维数组转为一维数组求算术平均值
axis=0时求每列的平均值
axis=1时求每行的平均值

4.5 average

np.average(arr,weights):求数组的加权平均值

加权平均值：数组中所有元素与对应的权重的积之和

4.6 var/std

np.var(arr,ddof):求方差

如果不指定ddof=1，则求整体方差
如果ddof=1，则求样本方差
默认不指定ddof，默认求总体方差

np.std():求标准差，即方差开更号

import numpy as np


#amin:求数组中最小值，axis=0时找每列中的最小值，axis=1时找每行中的最小值
#amax:求数组中最大值，axis=0时找每列中的最大值，axis=1时找每行中的最大值
#ptp:求数组中最大值和最小值的差，axis=0，求每列中最大值和最小值的差，axis=1，求每行中最大值和最小值的差
def arr_min():
    arr = np.array([[1,22,2],[3,233,4],[5,6,7]])
    arr1 = np.amin(arr,0)
    print(arr1)
    arr2 = np.amin(arr,1)
    print(arr2)

    arr3 = np.amax(arr,0)
    print(arr3)
    arr4 = np.amax(arr,1)
    print(arr4)

    arr5 = np.ptp(arr,0)
    print(arr5)
    arr6 = np.ptp(arr,1)
    print(arr6)
# arr_min()


#np.median(arr,axis):求中位数，即按照数值从大到小排列后中间的元素值，如果元素个数为偶数则中位数为中间两个元素值的平均值，如果元素个数为奇数则为元素本身
#axis=0，找每列的中位数
#axis=1，找每行的中位数
#axis=None，将数组转为一维数组找中位数
def arr_median():
    arr = np.array([[1,3,5],[2,4,6]])
    arr1 = np.median(arr)
    print(arr1)

    arr2 = np.median(arr,0)
    print(arr2)
    arr3 = np.median(arr,1)
    print(arr3)

# arr_median()


#np.mean(arr,axis):求数组中的算术平均值
#axis=None时将多维数组转为一维数组求算术平均值
#axis=0时求每列的平均值
#axis=1时求每行的平均值
def arr_mean():
    arr = np.array([[1,2,3],[77,88,99]])
    arr1 = np.mean(arr)
    print(arr1)
    arr2 = np.mean(arr,0)
    print(arr2)
    arr3 = np.mean(arr,1)
    print(arr3)

# arr_mean()


#np.average(arr,weights):求数组的加权平均值
#加权平均值：数组中所有元素与对应的权重的积之和
def arr_average():
    arr = np.array([1,2,3,4,5,6])
    weights = np.array([0.1,0.2,0.2,0.3,0.1,0.1])
    arr1 = np.average(arr,weights=weights)
    print(arr1)

# arr_average()


#np.var(arr,ddof):求方差
#如果不指定ddof=1，则求整体方差
#如果ddof=1，则求样本方差
#默认不指定ddof，默认求总体方差

#np.std():求标准差，即方差开更号
def arr_var():
    arr = np.array([1,2,3,4,5])
    arr1 = np.var(arr)
    print(arr1)
    arr2 = np.var(arr,ddof=1)
    print(arr2)

    arr3 = np.std(arr)
    print(arr3)
    arr4 = np.std(arr,ddof=1)
    print(arr4)

arr_var()