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

安装

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