Numpy快速入门（1）

一、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 np

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

# 访问第一个元素
print(arr[0, 0])  # 1

# 访问最后一个元素
print(arr[-1, -1])  # 6

2.切片（Slicing）：
使用切片可以获取数组的子集，即从数组中选择一部分元素。切片操作使用冒号:进行分隔，可以指定起始索引、终止索引和步长。

import numpy as np

arr = 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 np

arr = 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 np

arr = 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 np

arr = 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 np

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