Numpy基础：数组、矢量计算以及ufunc通用函数使用

最新推荐文章于 2024-06-18 11:50:53 发布

墨岚❤️

最新推荐文章于 2024-06-18 11:50:53 发布

阅读量1.2k

点赞数 1

分类专栏： python 数据处理与分析文章标签： numpy

本文链接：https://blog.youkuaiyun.com/LY_ysys629/article/details/73618531

版权

python 同时被 2 个专栏收录

29 篇文章

订阅专栏

数据处理与分析

18 篇文章

订阅专栏

本文详细介绍了Numpy的ndarray对象，包括常用的数组创建方法、数组与标量的运算、索引与切片、数组转置和轴对换，以及重点讨论了通用函数(ufunc)的元素级运算。通过实例展示了如何进行矢量化处理、广播功能和布尔型索引，强调了ufunc在数据处理中的高效性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Numpy-darray多数组对象

ndarry是一种通用的同构数据多维容器，即，容器里的所有元素都是相同类型的。每个数组元素都有一个shape（多维数组的行列数）和dtype（元素类型）属性。

1 常用的数组创建函数

函数	说明
array	将输入数据（列表、元组、数组、或其他序列类型）转换成narray，可以在转换的过程中指定dtype，或者默认与原数据类型相同
asarray	将输入数据转换成ndarray，如果输入本身就是一个ndarray就不进行复制
arange	类似于内置的range，但返回的是一个narray而不是一个列表
ones、ones_like	根据指定的形状和dtype创建全1数组。ones_like以另外一个数组为参数，并根据其形状和dtype穿件一个全1数组
zeros、zeros_like	类似于ones、ones_like，但是创建的是全0数组
empty、empty_like	创建新数组，只分配内存空间但不填充任何值
eye、identity	创建单位方阵

import numpy as np


#生成一个原始数组
arrayInit = np.arange(2,10,2)
arrayInit

array([2, 4, 6, 8])

print arrayInit.shape,arrayInit.dtype

(4L,) int32

可以通过reshape（n,m）来改变原始数组的行列分布

arrayInit.reshape(2,2)

array([[2, 4],
       [6, 8]])

注意reshape并不改变原来的数组

演示使用asarray

np.asarray(arrayInit)

array([2, 4, 6, 8])

arrayInit

array([2, 4, 6, 8])

arrayOne = np.arange(6).reshape(2,3)
arrayOne

array([[0, 1, 2],
       [3, 4, 5]])

np.asarray(arrayOne)

array([[0, 1, 2],
       [3, 4, 5]])

tem = [1,2,3]
np.asarray(tem)

array([1, 2, 3])

tem

[1, 2, 3]

从上述代码中可以看出，这些函数仅是创建新的narray，并不改变原来的输入数据，若想保留该创建需要创建新的变量

2 数组和标量之间的运算

矢量化：可以对数据执行批量运算。数组可以实现矢量化，大小相等的数组之间的任何算数运算都会将运算应用到元素级

arrayTwo = np.array([[1,2,3],[4,5,6]])#将列表转换成narray
arrayTwo

array([[1, 2, 3],
       [4, 5, 6]])

arrayTwo * arrayTwo

array([[ 1,  4,  9],
       [16, 25, 36]])

arrayTwo**2

array([[ 1,  4,  9],
       [16, 25, 36]])

arrayTwo + arrayTwo

array([[ 2,  4,  6],
       [ 8, 10, 12]])

广播：不同大小的数组之间的运算

1.0/arrayTwo.astype(float)#astype并不改变原数组

array([[ 1.        ,  0.5       ,  0.33333333],
       [ 0.25      ,  0.2       ,  0.16666667]])

arrayTwo

array([[1, 2, 3],
       [4, 5, 6]])

1.0/arrayTwo

array([[ 1.        ,  0.5       ,  0.33333333],
       [ 0.25      ,  0.2       ,  0.16666667]])

3 narray基本的索引和切片

索引，注意索引会修改原数组，除非用.copy（）重新赋值

array3 = np.arange(10)
array3[5]

array3[5:8] =12
array3

array([ 0,  1,  2,  3,  4, 12, 12, 12,  8,  9])

arraytem = array3[1:4]
arraytem

array([1, 2, 3])

arraytem[:] = 12
array3

array([ 0, 12, 12, 12,  4, 12, 12, 12,  8,  9])

array4 = array3[8:10].copy()

array4

array([8, 9])

array4[:] = 0

array3

array([ 0, 12, 12, 12,  4, 12, 12, 12,  8,  9])

切片索引

array5 = np.ones((3,4))

array5

array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]])

array5[2]#取出第三行向量

array([ 1.,  1.,  1.,  1.])

array5[1][1]

1.0

array5[1,1]

1.0

array5[1,:1]

array([ 1.])

注意上述两行命令的结果不同，虽然都是取出一个数，但是，行列号直接索引的结果是一个元素数据，存在切片的返回结果是narray.

布尔型索引

布尔型数组的长度必须跟被索引的轴长度一致。此外，布尔型数组还可以和切边，整数混合使用。

data = np.arange(32).reshape((8,4))
data

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]])


char = np.array(['a','b','c','d','e','f','g','h'])

char == 'b'

array([False,  True, False, False, False, False, False, False], dtype=bool)

data[char == 'b']#布尔型索引返回的与原数据一样的类型，返回矩阵

array([[4, 5, 6, 7]])

data[char == 'b'][:,3]

array([7])

data[1,3]

data[1:2,3]

array([7])

data[char == 'b'][0]#取出数组

array([4, 5, 6, 7])

花式索引

花式索引是利用整数数组进行索引的。

array6 = np.empty((8,4))

for i in range(8):
    array6[i] =i
array6

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.]])

array6[[4,3,0]]#花式索引传入列表，array会按照列表元素进行索引

array([[ 4.,  4.,  4.,  4.],
       [ 3.,  3.,  3.,  3.],
       [ 0.,  0.,  0.,  0.]])

array6[[-1,-2,-3]]#从后索引

array([[ 7.,  7.,  7.,  7.],
       [ 6.,  6.,  6.,  6.],
       [ 5.,  5.,  5.,  5.]])

array7 = array6[[-1,-2,-3]]

array7

array([[ 7.,  7.,  7.,  7.],
       [ 6.,  6.,  6.,  6.],
       [ 5.,  5.,  5.,  5.]])

array7[1] =0

array7

array([[ 7.,  7.,  7.,  7.],
       [ 0.,  0.,  0.,  0.],
       [ 5.,  5.,  5.,  5.]])

array6

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.]])

注意，花式索引和切片不一样，花式索引会返回一个新数组，改变新数组的值不影响原来的数组

4 数组转置和轴对换

转置（transpose）是重塑的一种特殊形式，它返回的是原数据的视图（不会进行任何复制操作）。

array8 = np.arange(15).reshape((3,5))
array8

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

array8.transpose()

array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])

array8.T

array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])

np.dot(array8,array8.T)#计算矩阵内积

array([[ 30,  80, 130],
       [ 80, 255, 430],
       [130, 430, 730]])

看下复杂的轴变换，在三维空间

array9 = np.arange(16).reshape((2,2,4))
array9

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

array9.T#结果看着有点蒙圈~

array([[[ 0,  8],
        [ 4, 12]],

       [[ 1,  9],
        [ 5, 13]],

       [[ 2, 10],
        [ 6, 14]],

       [[ 3, 11],
        [ 7, 15]]])

array9.transpose((0,2,1))

array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

array9.transpose((1,0,2))

array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

array9.swapaxes(1,2)

array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

5 划重点—通用函数：快速的元素级数组函数

通用函数（即ufunc）是一种对ndarray中的数据执行元素级运算的函数。他有一个好听的名字–矢量化包装器

下边将会给出两个通用函数表格，一元ufunc和二元ufunc

函数	说明
abs、fabs	计算整数、浮点数或复数的绝对值。对应非复数，可以使用更快的fabs
sqrt	计算各元素平方根，相当于array * * 0.5
square	计算各元素平方，相当于array * * 2
exp	计算各元素的指数
log、log10、log2、log1p	分别以自然对数（底数e）、10、2、（1+x）的对数
sign	计算各元素的正负号：1（正数）、0（零）、-1（负数）
ceil	计算各元素的ceiling值，即大于等于该值的最小整数
floor	计算各元素的floor值，即小于等于该值的最大正数
rint	将各元素值四舍五入到最接近的整数，保留dtype
modf	将数组的小数和整数部分已两个独立数组的形式返回
isnan	返回一个表示“哪些是NAN”的布尔型数组
isfinite、isinf	返回一个表示“哪些是finite、inf”的布尔型数组
cos、cosh、sin、sinh、tan、tanh	普通型和双曲线三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函数
logical_not	计算各元素not x的真值，相当于-arr

函数	说明
add	将数组中对应的元素相加
subtract	从第一个数组中的元素减去第二个数组中的元素
multiply	数组元素相乘
divide、floor_dixide	除法、向下圆整除法（丢弃余数）
power	对第一个数组中元素A，根据第二个数组中的相应位置元素B，计算A^B
maximum、fmax	元素级的最大值计算，fmax将忽略NaN
minimum、fmin	元素级的最小值计算，fmin将忽略NaN
mod	元素级的求模计算，（除法的余数）
greater、greater_equal、less、less_equal、equal、not_equal	执行元素级的比较运算，最终产生布尔型数组。相当于中缀运算符>、>=、<、<=、==、！=
logical_and、logical_or、logical_xor	执行元素级的真值逻辑运算。相当于中缀运算&、^

array8

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

array = array8[:,:4]
array

array([[ 0,  1,  2,  3],
       [ 5,  6,  7,  8],
       [10, 11, 12, 13]])

array7

array([[ 7.,  7.,  7.,  7.],
       [ 0.,  0.,  0.,  0.],
       [ 5.,  5.,  5.,  5.]])

np.sqrt(array8)

array([[ 0.        ,  1.        ,  1.41421356,  1.73205081,  2.        ],
       [ 2.23606798,  2.44948974,  2.64575131,  2.82842712,  3.        ],
       [ 3.16227766,  3.31662479,  3.46410162,  3.60555128,  3.74165739]])

np.cos(array8)

array([[ 1.        ,  0.54030231, -0.41614684, -0.9899925 , -0.65364362],
       [ 0.28366219,  0.96017029,  0.75390225, -0.14550003, -0.91113026],
       [-0.83907153,  0.0044257 ,  0.84385396,  0.90744678,  0.13673722]])

np.add(array,array7)

array([[  7.,   8.,   9.,  10.],
       [  5.,   6.,   7.,   8.],
       [ 15.,  16.,  17.,  18.]])

总结

本篇博客主要介绍了，python的数据分析库numpy的创建、索引和切片、通用函数的基本操作指令。