Numpy详细函数&属性

最新推荐文章于 2025-03-09 22:38:21 发布

余生羁绊

最新推荐文章于 2025-03-09 22:38:21 发布

阅读量1.7k

点赞数 9

分类专栏： Numpy Python 可视化

本文链接：https://blog.csdn.net/m0_46202060/article/details/117093170

版权

Python 同时被 3 个专栏收录

23 篇文章

订阅专栏

可视化

23 篇文章

订阅专栏

Numpy

9 篇文章

订阅专栏

常用创建数组方法：
在这里插入图片描述
numpy属性：

Numpy常用函数：
在这里插入图片描述

实验环境

Python 3.6
Jupyter

实验代码

1、Numpy.ndarray函数

1.ndarray的属性

import numpy as np

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

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

1）使用shape查看a的形状

a.shape

(3, 5)

2) 使用ndim查看a的维数

a.ndim

4) 使用dtype查看a的数据类型

a.dtype.name

'int32'

5) 查看数组a的元素个数

a.itemsize

6) 查看a的类型

type(a)

numpy.ndarray

2.创建数组ndarray

array()：将列表、元组转化成ndarray，使用array创建数组，数组的类型是由列表中元素的类型决定。

a = np.array([2,3,4])a

array([2, 3, 4])

1）查看数组a的数据类型

a.dtype

dtype('int32')

b = np.array([1.2,3.5,5.1])
b

array([1.2, 3.5, 5.1])

2) 查看数组b的数据类型

b.dtype

dtype('float64')

3.使用array函数将元组转化成数组

array1 = np.array(((1,2,3),(2,3,4)))
array1

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

4.array创建数组时，可以定义数据类型

c = np.array([[1,2,3],[1.2,3.5,6]],dtype = np.float64)
c

array([[1. , 2. , 3. ],
       [1.2, 3.5, 6. ]])

5.zeros():创建全为0的数组

1）使用zeros函数创建一个全为0的3行4列的数组

array_zeros = np.zeros((3,4))array_zeros

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

6.ones():创建全为1的数组

1）使用ones函数创建一个全为1的形状为（2,3,4）的3维数组，数据类型为int16

array_ones = np.ones((2,3,4))array_ones

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

7.empty():创建随机数组

1) 使用empty函数创建一个形状为（2,3）的随机数组，它的元素值是随机的，以内存的状态决定。

array_empty = np.empty((2,3))  array_empty

array([[1. , 2. , 3. ],       [1.2, 3.5, 6. ]])

8.arange()：

1) 使用Numpy中类似于range的函数arange，创建一个从10到30间隔为5的数值序列，结果返回到一个数组中。

array_arange=np.arange(10,30,5)array_arange

array([10, 15, 20, 25])

9.linspace()：

1) 使用Numpy中的linspace函数创建一个从0到2间隔为9的浮点类型数值序列，结果返回到一个数组中。

array_linspace = np.linspace(0,2,9)array_linspace

array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])

10.asarray()：Numpy.asarray类似于numpy.array，从已知数据中构造数组。

1) 使用asarray函数将列表[1,2,3]转换成数组，并定义数据类型为float64。

x = [1,2,3]a = np.asanyarray(x,dtype = np.float64)a

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

11.identity()：用于创建单位矩阵

这个函数和之前的区别在于，这个只能创建方阵，也就是N=M

函数的原型：np.identity(n,dtype=None)

参数：n，int型表示的是输出的矩阵的行数和列数都是n

dtype：表示的是输出的类型，默认是float

返回的是nxn的主对角线为1，其余地方为0的数组

1) 使用identity创建3单位矩阵。

array_identity = np.identity(3)array_identity

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

array_identity.ndim

12.eye():

函数的原型：numpy.eye(N,M=None,k=0,dtype=<class ‘float’>,order='C)

返回的是一个二维2的数组(N,M)，对角线的地方为1，其余的地方为0.

参数介绍：

（1）N:int型，表示的是输出的行数

（2）M：int型，可选项，输出的列数，如果没有就默认为N

（3）k：int型，可选项，对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角。

（4）dtype：数据的类型，可选项，返回的数据的数据类型

（5）order：{‘C’，‘F’}，可选项，也就是输出的数组的形式是按照C语言的行优先’C’，还是按照Fortran形式的列优先‘F’存储在内存中

a = np.eye(3)a

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

b = np.eye(3,k=1)b

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

c = np.eye(3,k=-1)c

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

13.diag()：用于创建对角矩阵。

1) 使用diag函数创建[1,2,3]的对角矩阵。

array_diag = np.diag([1,2,3]) 
array_diag

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

14.random.randint()：用于创建随机整数数组。

1) 使用random.randint函数创建一个取值由0到50之间的5个整数组成的一维数组。

array_randint = np.random.randint(0,50,5)
array_randint

array([21, 19, 41, 47, 17])

2) 使用random.randint函数创建一个 3行5列，介于0和50之间的整数的数组。

array_randint2 = np.random.randint(0,50,(3,5))
array_randint2

array([[47, 47,  8, 44, 40],       [40,  9, 30, 32,  8],       [29, 27, 16, 30, 45]])

15.random.rand()：用于创建取值为0到1之间的随机小数数组。

1) 使用random.rand函数创建大小为10的1维数组。

array_rand = np.random.rand(10)array_rand

array([0.17349901, 0.79770357, 0.49589733, 0.27765088, 0.48102378,       0.31433779, 0.49579309, 0.78099342, 0.60287197, 0.40863683])

16.random.standard_normal()：用于从标准正态分布中随机抽样。

1) 使用random.standard_normal函数创建一个大小为5的一维数组.

array_standard_normal = np.random.standard_normal(5)array_standard_normal

array([ 1.14664279,  1.16465956, -0.0302402 ,  1.47208368, -0.00533638])

2) 使用random.standard_normal函数创建一个形状为(3,4,2)的3维数组.

arr2 = np.random.standard_normal(size = (3,4,2))
arr2

array([[[ 1.18635502, -0.22768332],
        [-0.17322923, -1.64753943],
        [ 0.78037571, -0.03175083],
        [-1.91916739,  1.79037994]],

       [[ 0.61313302,  1.66755059],
        [-0.63485406,  0.20376679],
        [ 0.49881433,  0.55063801],
        [ 1.09693164,  2.13867619]],

       [[-0.93612589,  0.81342552],
        [-0.03872706, -0.54880053],
        [ 0.64529897, -0.89777152],
        [ 0.16477402,  0.66994561]]])

2、数组的变形操作

1.使用ravel函数来实现展平操作。

array1 = np.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]]]) 
array1

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

array1.ravel()

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

2.flatten，功能与ravel函数相同，不过flatten会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图

array1 = np.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]]])
array1

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

array1.flatten()

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

3.shape函数用于设置数组维度，给其赋予一个元组数值，修改的是数组本身。

array1 = np.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]]])
array1

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

array1.shape = (6,4)
array1

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

4.reshape方法用于修改数组的形状，返回一个修改完的新数组，原来的数组没有被修改。

array1=np.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]]])
array1

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

array2 = array1.reshape(6,4)
array2

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

array1

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

5.resize：方法用于修改数组的形状，无返回值，即会对原始多维数组进行修改。

array1=np.array([[1,2,3],[4,5,6]])  array1.resize((3,2))  array1

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

3、修改数组元素的值

1.使用arange方法创建数值从0到7的数组，并使用append方法在数组x后新增元素8，并返回新数组，数组x不改变。

x=np.arange(8)  
x

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

a = np.append(x,8)  
a

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

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

2.修改数组x本身的值，将数组下标3位置的元素值修改为8

x=np.arange(8)  x

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

x[3]=8  x

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

3.使用arange函数创建一个1到9的3行3列数组x，使用下标的方式修改x数组本身第0行第2列的元素值为4

x=np.arange(1,10).reshape(3,3)  x

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

x[0,2]=4
x[1,2]=4
x

array([[1, 2, 4],
       [4, 5, 4],
       [7, 8, 9]])

4.使用insert方法，在指定数组下标位置插入元素，返回新数组，原数组的值不改变。在数组x下标为1的位置插入9，查看返回的新数组。

x=np.arange(8)  
x

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

a = np.insert(x,1,9)a

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

5.repeat元素的重复，返回一个新数组.

x = np.arange(8)x.repeat(2)

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

6.使用put方法修改指定位置上的元素，将数组x索引为0的位置的元素值改为9。

x = np.arange(8)x

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

x.put(0,9)x

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

4、数组与数值运算

1.创建一个大小为5，从1到5的整型一维数组对象x.

x=np.array([1,2,3,4,5]) x

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

2.数组x与数值2进行相乘运算，查看返回的新数组。

x*2

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

3.数组x对数值2进行相除运算，查看返回的新数组。

x/2

array([0.5, 1. , 1.5, 2. , 2.5])

4.数组x对数值2进行整除运算，查看返回的新数组.

x//2

array([0, 1, 1, 2, 2], dtype=int32)

5.数组x对数值3的幂运算，查看返回的新数组。

x**3

array([  1,   8,  27,  64, 125], dtype=int32)

6.数组x与数值2相加，查看返回的新数组。

x+2

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

7.数组x对数值3进行取余运算，查看返回的新数组。

x%3

array([1, 2, 0, 1, 2], dtype=int32)

8.数值2对数组x的幂运算，查看返回结果。

2**x

array([ 2,  4,  8, 16, 32], dtype=int32)

9.数值2对数组x进行除法运算，查看返回结果。

2/x

array([2.        , 1.        , 0.66666667, 0.5       , 0.4       ])

10.数值63对数组x进行整除运算，查看返回结果。

63//x

array([63, 31, 21, 15, 12], dtype=int32)

5、数组与数组的运算

1.使用array函数将元组（1,2,3）创建成数组a，将包含3个列表的元组([1, 2, 3], [4, 5, 6], [7, 8, 9])创建成数组b。

a=np.array((1,2,3))  
a

array([1, 2, 3])

b=np.array(([1,2,3],[4,5,6],[7,8,9])) b

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

2.数组a与数组b相乘，将包含结果的新数组赋值给c,查看数组c的结果，可以看出数组a与数组b每行对应项相乘。

c = a*bc

array([[ 1,  4,  9],       [ 4, 10, 18],       [ 7, 16, 27]])

3.数组c除以数组b，查看结果数组的值，可看出数组c与数组b对应位置的值相除。

c/b

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

4.数组c除以数组a，查看结果数组，可以看出是数组c每行与数组a对应位置的值相除。

c/a

array([[1., 2., 3.],       [4., 5., 6.],       [7., 8., 9.]])

5.数组a与数组a相加，查看结果数组，可以看出是对应项相加。

a+a

array([2, 4, 6])

6.数组a与数组a相乘，查看结果数组，可以看出是对应项相乘。

a*a

array([1, 4, 9])

7.数组a与数组a相减，查看结果数组，可以看出是对应项相减。

a-a

array([0, 0, 0])

8.数组a与数组a相除，查看结果数组，可以看出是对应项相除。

a/a

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

6、数组转置

1.使用array函数将元组([1, 2, 3], [4, 5, 6], [7, 8, 9])创建成一个数组b。

b=np.array(([1,2,3],[4,5,6],[7,8,9]))
b

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

2.使用T对数组b进行转置，将数组b的行与列的值对换。

b.T

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

3.一维数组转置还是一维数组。创建一个1到4的整型数组a，对a进行转置。

a=np.array((1,2,3,4))  a

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

a.T

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

7、数组排序

列排列np.msort(a)，
行排列np.sort(a)，
np.argsort(a)排序后返回下标

1.np.argsort()排序后返回下标，创建一个值为[3,1,2]的数组x，使用argsort函数对数组x进行排序，返回原数组从小到大的元素下标组成的数组index_array。

x=np.array([3,1,2])  index_array=np.argsort(x)  index_array

array([1, 2, 0], dtype=int64)

2.将index_array带入到数组x中，将排序后的数组元素输出。

x[index_array]

array([1, 2, 3])

3.使用sort方法对数组进行原地排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  x.sort()  x

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

4.创建一个数值为[[0, 3, 4], [2, 2, 1]]的2维数组x，使用argsort函数加上参数axis=0对数组x进行纵向排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  x

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

a = np.argsort(x,axis=0)a

array([[0, 1, 1],       [1, 0, 0]], dtype=int64)

5.使用argsort函数加参数axis=1对数组x进行横向排序。

np.argsort(x,axis=1)

array([[0, 1, 2],
       [2, 0, 1]], dtype=int64)

6.使用sort方法加参数axis=1对数组x进行原地横向排序

x.sort(axis=1)  
x

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

7.使用sort方法和参数axis=0对数组x进行原地纵向排序。

x.sort(axis=0)  
x

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

8.numpy.sort(a, axis=-1, kind=‘quicksort’, order=None)

参数说明：

a：一个要排序的数组array，

axis：整数或None，如果axis=None，数组在排序之前将被展平，默认axis=-1，将排序按最后一列排序

kind：排序用到的算法，可选项 {‘quicksort’, ‘mergesort’, ‘heapsort’}，默认为quicksort

order：要进行排序的区域，

返回：一个与a相同数据类型和形状的数组。

使用numpy中的sort函数，加参数axis=None对数组x进行排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  
a = np.sort(x,axis=None) 
a

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

9.使用numpy中的sort函数，加参数axis=-1对数组x进行横向排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  
a = np.sort(x,axis=-1)
a

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

10.使用numpy中的sort函数，加参数axis=1对数组x进行横向排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  
a = np.sort(x,axis=1) 
a

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

11.使用numpy中的sort函数，加参数axis=0对数组x进行纵向排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  
a = np.sort(x,axis=0)  
a

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

12.np.msort()相当于np.sort(axis=0)，使用numpy中的msort函数，对数组x进行纵向排序。

x=np.array([[0, 3, 4], [2, 2, 1]])  
a = np.msort(x)  
a

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

13.创建姓名、身高、年龄的数组，使用numpy中的sort函数对数组x按年龄进行排序，如年龄相同按身高排序。

dtype = [('name', 'S10'), ('height', float), ('age', int)]  
values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),('Galahad', 1.7, 38)]  
x = np.array(values, dtype=dtype)  
a = np.sort(x, order=['age', 'height']) 
a

array([(b'Galahad', 1.7, 38), (b'Lancelot', 1.9, 38),
       (b'Arthur', 1.8, 41)],
      dtype=[('name', 'S10'), ('height', '<f8'), ('age', '<i4')])