Python-NumPy快速入门基础知识点

最新推荐文章于 2023-04-22 16:11:08 发布

YANGGEOL

最新推荐文章于 2023-04-22 16:11:08 发布

阅读量185

点赞数 1

分类专栏： Python 文章标签： python numpy

本文链接：https://blog.csdn.net/qq_46253184/article/details/109871771

版权

Python 专栏收录该内容

11 篇文章 6 订阅

订阅专栏

安装

pip install numpy

基础

NumPy的主要对象是齐次多维数组。它是所有相同类型的元素（通常为数字）表，由非负整数元组索引。在NumPy中，尺寸称为轴。

NumPy的数组类称为ndarray。也被称为别名 array。numpy.array这与标准Python库类不同array.array，后者仅处理一维数组且功能较少。

`ndarray.ndim`

数组的轴（尺寸）数。

`ndarray.shape`

数组的尺寸。这是一个整数元组，指示每个维度中数组的大小。对于具有n行和m列的矩阵，shape将为(n,m)。shape因此，元组的长度为轴数ndim。

`ndarray.size`

数组元素的总数。这等于的元素的乘积shape。

`ndarray.dtype`

一个对象，描述数组中元素的类型。可以使用标准Python类型创建或指定dtype。另外，NumPy提供了自己的类型。

`ndarray.itemsize`

数组中每个元素的大小（以字节为单位）。例如，类型为元素的数组float64具有itemsize8（= 64/8），而类型complex32中的一个具有itemsize4（= 32/8）。等同于ndarray.dtype.itemsize。

`ndarray.data`

包含数组实际元素的缓冲区。通常，我们不需要使用此属性，因为我们将使用索引工具访问数组中的元素。

例子

import numpy as np

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

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

a.shape
Out[4]: (3, 5)

a.ndim
Out[5]: 2

a.dtype.name
Out[6]: 'int32'

a.itemsize
Out[7]: 4

a.size
Out[8]: 15

type(a)
Out[9]: numpy.ndarray

b=np.array([6,7,8])

b
Out[11]: array([6, 7, 8])

type(b)
Out[12]: numpy.ndarray

数组创建

import numpy as np
# 创建一维数组
a = np.array([2,3,4])

a
Out[14]: array([2, 3, 4])

# 创建二维数组 三维乃至更高 以此类推
b = np.array([(1.5,2,3),(4,5,6)])

b
Out[16]: 
array([[1.5, 2. , 3. ],
       [4. , 5. , 6. ]])

# 创建指明类型
c = np.array( [ [1,2], [3,4] ], dtype=complex )

c
Out[18]: 
array([[1.+0.j, 2.+0.j],
       [3.+0.j, 4.+0.j]])

# 创建一个全0的数组
np.zeros((3,4))
Out[19]: 
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

# 创建一个全1的数组
np.ones((1,2))
Out[21]: array([[1., 1.]])
 
# 创建其初始内容是随机的并取决于内存状态的数组
np.empty((2,3))
Out[23]: 
array([[1.5, 2. , 3. ],
       [4. , 5. , 6. ]])

# 为了创建数字序列，NumPy提供了arange类似于Python内置函数的功能range，但是返回一个数组。
np.arange(10,30,5)
Out[25]: array([10, 15, 20, 25])
    
# 当arange用浮点参数使用时，它通常是不可能预测得到的元件的数量，由于有限浮点精度。出于这个原因，通常最好使用linspace接收所需元素数量而不是步骤的函数作为参数：
# 0到2之间有9个数
np.linspace(0,2,9)
Out[27]: array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])

基本操作

a = np.array([20,30,40,50])

b = np.arange(4)

a
Out[33]: array([20, 30, 40, 50])

b
Out[34]: array([0, 1, 2, 3])

c=a-b

c
Out[36]: array([20, 29, 38, 47])

b**2
Out[37]: array([0, 1, 4, 9], dtype=int32)

10*np.sin(a)
Out[38]: array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])

a<35
Out[39]: array([ True,  True, False, False])

乘积运算符*在NumPy数组中按元素进行操作。可以使用@运算符（在python> = 3.5中）或dot函数或方法执行矩阵乘积

A = np.array([[1,1],[0,1]])

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

A*B
Out[43]: 
array([[2, 0],
       [0, 4]])

A@B
Out[44]: 
array([[5, 4],
       [3, 4]])

A.dot(B)
Out[45]: 
array([[5, 4],
       [3, 4]])

+=和*=就位以修改现有数组，而不是创建一个新数组

A += B

A
Out[47]: 
array([[3, 1],
       [3, 5]])

A *=B

A
Out[49]: 
array([[ 6,  0],
       [ 9, 20]])

许多一元运算（例如计算数组中所有元素的总和）都作为ndarray该类的方法实现

# 创建默认随机数生成器的实例
rg = np.random.default_rng(1)

a=rg.random((2,3))

a
Out[58]: 
array([[0.51182162, 0.9504637 , 0.14415961],
       [0.94864945, 0.31183145, 0.42332645]])

a.sum()
Out[59]: 3.290252281866131

a.min()
Out[60]: 0.14415961271963373

a.max()
Out[61]: 0.9504636963259353

通过指定axis 参数，您可以沿数组的指定轴应用操作

b = np.arange(12).reshape(3,4)

b
Out[63]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

# 每列的总和
b.sum(axis=0)
Out[64]: array([12, 15, 18, 21])

# 每行的最小值
b.min(axis=1)
Out[65]: array([0, 4, 8])

# 每一行的累计总和
b.cumsum(axis=1)
Out[66]: 
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]], dtype=int32)

通用功能

NumPy提供了熟悉的数学函数，例如sin，cos和exp。在NumPy中，这些被称为“通用函数”（ufunc）。在NumPy中，这些函数在数组上逐元素操作，从而生成数组作为输出。

b = np.arange(3)

b
Out[68]: array([0, 1, 2])

np.exp(b)
Out[69]: array([1.        , 2.71828183, 7.3890561 ])

np.sqrt(b)
Out[70]: array([0.        , 1.        , 1.41421356])
 
c=np.array([2.,-1,4.])

np.add(b,c)
Out[73]: array([2., 0., 6.])

索引，切片及循环

一维数组可以被索引，切片和遍历

a = np.arange(10)

a
Out[75]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a[2]
Out[76]: 2

a[2:5]
Out[77]: array([2, 3, 4])

# 从开始到位置6，排序，将每个第二元素设置为1000
a[:6:2] = 1000

a
Out[79]: array([1000,    1, 1000,    3, 1000,    5,    6,    7,    8,    9])

# 倒序输出
a[::-1]
Out[80]: array([   9,    8,    7,    6,    5, 1000,    3, 1000,    1, 1000])

# 循环遍历
for i in a:
    print(i)
    
1000
1
1000
3
1000
5
6
7
8
9

多维数组每个轴可以有一个索引。这些索引以元组给出，并用逗号分隔

def f(x,y):
    return 10*x+y
    

b = np.fromfunction(f,(5,4),dtype=int)

b
Out[84]: 
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])

b[2,3]
Out[85]: 23

b[0:5,1]
Out[86]: array([ 1, 11, 21, 31, 41])

b[:,1]
Out[87]: array([ 1, 11, 21, 31, 41])

# b的第二行和第三行中的每一列
b[1:3,:]
Out[88]: 
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])

如果提供的索引数少于轴数，则将丢失的索引视为完整切片

点（...根据需要，以产生一个完整的索引元组）表示为许多冒号。例如，如果x是具有5个轴的数组，则

x[1,2,...]等于x[1,2,:,:,:]，
x[...,3]到x[:,:,:,:,3]和
x[4,...,5,:]到x[4,:,:,5,:]。

迭代过多维数组相对于第一轴线完成

如果要对数组中的每个元素执行操作，则可以使用该flat属性

for element in b.flat:
    print(element)

外形操纵

改变阵列形状

数组的形状由沿每个轴的元素数确定

a = np.floor(10*rg.random((3,4)))
a
array([[3., 7., 3., 4.],
       [1., 4., 2., 2.],
       [7., 2., 4., 9.]])
a.shape
(3, 4)

数组的形状可以使用各种命令来更改

a.ravel()  # returns the array, flattened
array([3., 7., 3., 4., 1., 4., 2., 2., 7., 2., 4., 9.])
a.reshape(6,2)  # returns the array with a modified shape
array([[3., 7.],
       [3., 4.],
       [1., 4.],
       [2., 2.],
       [7., 2.],
       [4., 9.]])
a.T  # returns the array, transposed
array([[3., 1., 7.],
       [7., 4., 2.],
       [3., 2., 4.],
       [4., 2., 9.]])
a.T.shape
(4, 3)
a.shape
(3, 4)

reshape函数以修改后的形状返回其参数，而 ndarray.resize方法修改了数组本身

堆叠在一起的不同阵列

几个数组可以沿着不同的轴堆叠在一起

a
array([[9., 7.],
       [5., 2.]])
b = np.floor(10*rg.random((2,2)))
b
array([[1., 9.],
       [5., 1.]])
np.vstack((a,b))
array([[9., 7.],
       [5., 2.],
       [1., 9.],
       [5., 1.]])
np.hstack((a,b))
array([[9., 7., 1., 9.],
       [5., 2., 5., 1.]])

在复杂的情况下，r_并且 c_是用于通过沿一个轴堆叠号码创建阵列有用的。它们允许使用范围文字（“：”）

np.r_[1:4,0,4]
array([1, 2, 3, 0, 4])

将一个数组拆分为几个较小的数组

使用hsplit，可以沿数组的水平轴拆分数组，方法是指定要返回的形状相同的数组的数量，或者指定要在其后进行划分的列

a = np.floor(10*rg.random((2,12)))
a
array([[6., 7., 6., 9., 0., 5., 4., 0., 6., 8., 5., 2.],
       [8., 5., 5., 7., 1., 8., 6., 7., 1., 8., 1., 0.]])
# Split a into 3
np.hsplit(a,3)
[array([[6., 7., 6., 9.],
       [8., 5., 5., 7.]]), array([[0., 5., 4., 0.],
       [1., 8., 6., 7.]]), array([[6., 8., 5., 2.],
       [1., 8., 1., 0.]])]
# Split a after the third and the fourth column
np.hsplit(a,(3,4))
[array([[6., 7., 6.],
       [8., 5., 5.]]), array([[9.],
       [7.]]), array([[0., 5., 4., 0., 6., 8., 5., 2.],
       [1., 8., 6., 7., 1., 8., 1., 0.]])]

vsplit沿垂直轴分割，并array_split允许指定沿哪个轴分割。

复制和视图

完全没有复制

简单分配不会复制对象或其数据.Python将可变对象作为引用传递，因此函数调用不会复制.

查看或浅拷贝

不同的数组对象可以共享相同的数据。该view方法创建一个查看相同数据的新数组对象。

c = a.view()
c is a
False
c.base is a 
True

切片数组将返回其视图

深度复制

该copy方法对数组及其数据进行完整复制

d = a.copy()                          # a new array object with new data is created
d is a
False
d.base is a                           # d doesn't share anything with a
False

函数和方法概述

这是按类别排序的一些有用的NumPy函数和方法名称的列表。

数组创建

arange， array， copy， empty， empty_like， eye， fromfile， fromfunction， identity， linspace， logspace， mgrid， ogrid， ones， ones_like， r_， zeros， zeros_like
转换次数

ndarray.astype， atleast_1d， atleast_2d， atleast_3d， mat
操作方式

array_split， column_stack， concatenate， diagonal， dsplit， dstack， hsplit， hstack， ndarray.item， newaxis， ravel， repeat， reshape， resize， squeeze， swapaxes， take， transpose， vsplit， vstack
问题

all， any， nonzero， where
订购方式

argmax， argmin， argsort， max， min， ptp， searchsorted， sort
运作方式

choose， compress， cumprod， cumsum， inner， ndarray.fill， imag， prod， put， putmask， real， sum
基本统计

cov， mean， std， var
基本线性代数

cross， dot， outer， linalg.svd， vdot

高级索引和索引技巧

NumPy提供了比常规Python序列更多的索引功能

用索引数组索引

a = np.arange(12)**2                       
i = np.array([1, 1, 3, 8, 5])            
a[i]                                    
array([ 1,  1,  9, 64, 25])

j = np.array([[3, 4], [9, 7]])     
a[j]                                      
array([[ 9, 16],
       [81, 49]])

当索引数组a为多维时，单个索引数组引用的第一维a。

还可以为多个维度提供索引。每个维度的索引数组必须具有相同的形状。

用布尔数组索引

使用（整数）索引数组对数组进行索引时，将提供要选择的索引列表。对于布尔索引，方法是不同的。显式选择数组中需要哪些项，不需要哪些项。

a = np.arange(12).reshape(3,4)
b = a > 4
b                                        
array([[False, False, False, False],
       [False,  True,  True,  True],
       [ True,  True,  True,  True]])
a[b]                                     
array([ 5,  6,  7,  8,  9, 10, 11])

使用布尔值建立索引的第二种方式与整数索引更相似；对于数组的每个维度，提供一个一维布尔数组来选择所需的切片

a = np.arange(12).reshape(3,4)
b1 = np.array([False,True,True])             
b2 = np.array([True,False,True,False])       

a[b1,:]                                
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

a[b1]                                   
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

a[:,b2]                                  
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])

a[b1,b2]                                  
array([ 4, 10])

ix_（）函数

ix_函数可用于组合不同的向量，以获得每个n片段的结果。例如，如果要计算从向量a，b和c中选取的所有三元组的所有a + b * c

a = np.array([2,3,4,5])
b = np.array([8,5,4])
c = np.array([5,4,6,8,3])
ax,bx,cx = np.ix_(a,b,c)
ax
array([[[2]],

       [[3]],

       [[4]],

       [[5]]])
bx
array([[[8],
        [5],
        [4]]])
cx
array([[[5, 4, 6, 8, 3]]])
ax.shape, bx.shape, cx.shape
((4, 1, 1), (1, 3, 1), (1, 1, 5))
result = ax+bx*cx
result
array([[[42, 34, 50, 66, 26],
        [27, 22, 32, 42, 17],
        [22, 18, 26, 34, 14]],

       [[43, 35, 51, 67, 27],
        [28, 23, 33, 43, 18],
        [23, 19, 27, 35, 15]],

       [[44, 36, 52, 68, 28],
        [29, 24, 34, 44, 19],
        [24, 20, 28, 36, 16]],

       [[45, 37, 53, 69, 29],
        [30, 25, 35, 45, 20],
        [25, 21, 29, 37, 17]]])
result[3,2,4]
17
a[3]+b[2]*c[4]
17