文章目录
- 一、Numpy是什么？
- 二、基础知识
- 1.数组创建
- 2.数组的索引、切片和迭代
- 3.形状操纵
一、Numpy是什么？
NumPy是一个开源的Python库，提供了多维数组对象（ndarray）和用于处理这些数组的函数。它是科学计算和数据分析的基础库之一，被广泛应用于各种领域，包括数值计算、数据处理、机器学习、图像处理等。
二、基础知识
NumPy的主要对象是同构多维数组。它是一个元素表（通常是数字），所有类型都相同，由非负整数元组索引。在NumPy维度中称为 轴 。
轴的数量和维度取决于数组的形状。例如，一个二维数组具有两个轴，一个三维数组具有三个轴，以此类推
import numpy as np
arr = np.array([[1, 2, 3],[4, 5, 6]])
这个数组有两个轴，第一个轴是行轴（axis 0），第二个轴是列轴（axis 1）。
NumPy的数组类被调用ndarray。它也被别名所知 array。请注意，numpy.array这与标准Python库类不同array.array，后者只处理一维数组并提供较少的功能。ndarray对象更重要的属性是：
- ndarray.ndim - 数组的轴（维度）的个数。在Python世界中，维度的数量被称为rank。
- ndarray.shape - 数组的维度。这是一个整数的元组，表示每个维度中数组的大小。对于有 n 行和 m 列的矩阵，shape 将是 (n,m)。因此，shape 元组的长度就是rank或维度的个数 ndim。
- ndarray.size - 数组元素的总数。这等于 shape 的元素的乘积。
- ndarray.dtype - 一个描述数组中元素类型的对象。可以使用标准的Python类型创建或指定dtype。另外NumPy提供它自己的类型。例如numpy.int32、numpy.int16和numpy.float64。
- ndarray.itemsize - 数组中每个元素的字节大小。例如，元素为 float64 类型的数组的
- itemsize 为8（=64/8），而 complex32 类型的数组的 itemsize 为4（=32/8）。它等于
ndarray.dtype.itemsize 。 - ndarray.data - 该缓冲区包含数组的实际元素。通常，我们不需要使用此属性，因为我们将使用索引访问数组中的元素。
>>> 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]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type 'numpy.ndarray'>
1.数组创建
1.使用列表（List）创建数组：
可以使用Python的列表来创建数组。使用numpy.array()函数将列表转换为NumPy数组。
import numpy as np# 创建一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1) # [1 2 3 4 5]# 创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
# [[1 2 3]
# [4 5 6]]
2.使用NumPy的函数创建数组：
NumPy提供了许多函数用于创建特定类型的数组。
- numpy.zeros()：创建全零数组。
- numpy.ones()：创建全一数组。
- numpy.full()：创建指定值的数组。
- numpy.arange()：创建指定范围的递增数组。
- numpy.linspace()：创建指定范围内的等间隔数组。
- numpy.random.rand()：创建随机数数组。
import numpy as np# 创建全零数组
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# [[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]# 创建全一数组
ones_arr = np.ones((2, 3))
print(ones_arr)
# [[1. 1. 1.]
# [1. 1. 1.]]# 创建指定值的数组
full_arr = np.full((2, 2), 5)
print(full_arr)
# [[5 5]
# [5 5]]# 创建递增数组
range_arr = np.arange(0, 10, 2)
print(range_arr) # [0 2 4 6 8]# 创建等间隔数组
linspace_arr = np.linspace(0, 1, 5)
print(linspace_arr) # [0. 0.25 0.5 0.75 1. ]# 创建随机数数组
rand_arr = np.random.rand(3, 2)
print(rand_arr)
# [[0.02738536 0.3610029 ]
# [0.80069856 0.87777731]
# [0.14728775 0.3642267 ]]
2.数组的索引、切片和迭代
1.索引（Indexing）：
使用索引可以访问数组中特定位置的元素。在NumPy中，索引从0开始，可以使用整数索引或负数索引（表示从末尾开始计数）来访问元素。
>>> a = np.arange(10)**3
>>> a
array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1000 # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
>>> a
array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])
>>> a[ : :-1] # reversed a
array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
>>> for i in a:
... print(i**(1/3.))
...
nan
1.0
nan
3.0
nan
5.0
6.0
7.0
8.0
9.0
对于多维数组，可以使用逗号分隔的索引来访问特定位置的元素。
示例：
import numpy as nparr = np.array([[1, 2, 3], [4, 5, 6]])# 访问第一个元素
print(arr[0, 0]) # 1# 访问最后一个元素
print(arr[-1, -1]) # 6
2.切片（Slicing）：
使用切片可以获取数组的子集，即从数组中选择一部分元素。切片操作使用冒号:进行分隔，可以指定起始索引、终止索引和步长。
import numpy as nparr = np.array([1, 2, 3, 4, 5])# 切片获取索引1到3的元素（不包括索引3）
print(arr[1:3]) # [2 3]# 切片获取从索引1开始的所有元素
print(arr[1:]) # [2 3 4 5]# 切片获取每隔一个元素的元素
print(arr[::2]) # [1 3 5]
对于多维数组，可以在每个维度上使用切片操作。
import numpy as nparr = np.array([[1, 2, 3], [4, 5, 6]])# 获取第一行的所有元素
print(arr[0, :]) # [1 2 3]# 获取第一列的所有元素
print(arr[:, 0]) # [1 4]# 获取子数组，包括第一行和第二行的前两列
print(arr[:2, :2])
# [[1 2]
# [4 5]]
>>> def f(x,y):
... return 10*x+y
...
>>> b = np.fromfunction(f,(5,4),dtype=int)
>>> b
array([[ 0, 1, 2, 3],[10, 11, 12, 13],[20, 21, 22, 23],[30, 31, 32, 33],[40, 41, 42, 43]])
>>> b[2,3]
23
>>> b[0:5, 1] # each row in the second column of b
array([ 1, 11, 21, 31, 41])
>>> b[ : ,1] # equivalent to the previous example
array([ 1, 11, 21, 31, 41])
>>> b[1:3, : ] # each column in the second and third row of b
array([[10, 11, 12, 13],[20, 21, 22, 23]])
b[i] 方括号中的表达式 i 被视为后面紧跟着 : 的多个实例，用于表示剩余轴。NumPy也允许你使用三个点写为 b[i,…]。
三个点（ … ）表示产生完整索引元组所需的冒号。例如，如果 x 是rank为5的数组（即，它具有5个轴），则：
- x[1,2,…] 相当于 x[1,2,:,:,:]，
- x[…,3] 等效于 x[:,:,:,:,3]
- x[4,…,5,:] 等效于 x[4,:,:,5,:]。
>>> c = np.array( [[[ 0, 1, 2], # a 3D array (two stacked 2D arrays)
... [ 10, 12, 13]],
... [[100,101,102],
... [110,112,113]]])
>>> c.shape
(2, 2, 3)
>>> c[1,...] # same as c[1,:,:] or c[1]
array([[100, 101, 102],[110, 112, 113]])
>>> c[...,2] # same as c[:,:,2]
array([[ 2, 13],[102, 113]])
对多维数组进行 迭代（Iterating） 是相对于第一个·轴完成的
>>> for row in b:
... print(row)
...
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]
3.形状操纵
1.查看数组的的形状
import numpy as nparr = np.array([[1, 2, 3], [4, 5, 6]])# 查看数组形状
print(arr.shape) # (2, 3)# 查看数组维度的数量
print(arr.ndim) # 2# 查看数组的总元素数量
print(arr.size) # 6
2.改变数组形状：
import numpy as nparr = np.array([1, 2, 3, 4, 5, 6])# 改变数组形状为2行3列的二维数组
reshaped_arr = arr.reshape((2, 3))
print(reshaped_arr)
# [[1 2 3]
# [4 5 6]]# 改变数组形状为3行2列的二维数组
reshaped_arr = arr.reshape((3, 2))
print(reshaped_arr)
# [[1 2]
# [3 4]
# [5 6]]
3.展平数组：
import numpy as nparr = np.array([[1, 2, 3], [4, 5, 6]])# 使用flatten()方法展平数组
flattened_arr = arr.flatten()
print(flattened_arr) # [1 2 3 4 5 6]# 使用ravel()方法展平数组
raveled_arr = arr.ravel()
print(raveled_arr) # [1 2 3 4 5 6]
4.将不同数组堆叠在一起
>>> a = np.floor(10*np.random.random((2,2)))
>>> a
array([[ 8., 8.],[ 0., 0.]])
>>> b = np.floor(10*np.random.random((2,2)))
>>> b
array([[ 1., 8.],[ 0., 4.]])
>>> np.vstack((a,b))
array([[ 8., 8.],[ 0., 0.],[ 1., 8.],[ 0., 4.]])
>>> np.hstack((a,b))
array([[ 8., 8., 1., 8.],[ 0., 0., 0., 4.]])
该函数将column_stack 1D数组作为列堆叠到2D数组中。它仅相当于 hstack2D数组：
>>> from numpy import newaxis
>>> np.column_stack((a,b)) # with 2D arrays
array([[ 8., 8., 1., 8.],[ 0., 0., 0., 4.]])
>>> a = np.array([4.,2.])
>>> b = np.array([3.,8.])
>>> np.column_stack((a,b)) # returns a 2D array
array([[ 4., 3.],[ 2., 8.]])
>>> np.hstack((a,b)) # the result is different
array([ 4., 2., 3., 8.])
>>> a[:,newaxis] # this allows to have a 2D columns vector
array([[ 4.],[ 2.]])
>>> np.column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4., 3.],[ 2., 8.]])
>>> np.hstack((a[:,newaxis],b[:,newaxis])) # the result is the same
array([[ 4., 3.],[ 2., 8.]])
