【Python】Numpy简单入门

Numpy

  Numpy是Python中科学计算的核心库。Numpy提供了高性能的多维数组对象，还有用于处理这些数组的工具。

  在这里给出Win10配置Python3、Numpy、PyCharm、Anaconda的方法: Python安装配置教程

  与Matlab有些共通的地方，也有不同之处，下面给出两者的差异。

  本节Python编程由PyCharm+Anaconda环境中运行，Win10配置方法见：http://blog.csdn.net/u013165921/article/details/78692421

---

数组

  Numpy的主要数据类型是ndarray即多维数组，可以用嵌套的Python列表中初始化numpy数组，并使用方括号访问元素。数组具有以下几个属性：

• ndarray.ndim：数组的维数
• ndarray.shape：数组每一维的大小
• ndarray.size：数组中全部元素的数量
• ndarray.dtype：数组中元素的类型（numpy.int32, numpy.int16, and numpy.float64等）
• ndarray.itemsize：每个元素占几个字节

数组操作

import numpy as np                   # 导入numpy模块

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

print(type(a))                       # a的类型是numpy.ndarray
print(a.shape)                       # 一维数组，列向量
print(a[0],a[1],a[2])                # 下标从0开始计数

a[0] = 5                             # 修改数组元素的值
print(a)

b = np.array([[1,2,3],[4,5,6]])      
print(b.shape)                       # 二维数组，2×3
print(b[0,0],b[0,1],b[1,0])          # 二维数组下标

c = np.array([1,])                   # 一维数组
print(c.shape)

运行结果

<class 'numpy.ndarray'>

(3,)

1 2 3

[5 2 3]

(2, 3)

1 2 4

(1,)

创建数组

import numpy as np

a = np.zeros((2,2))                  # 2×2全零数组
print(a)

b = np.ones((1,2))                   # 2×2全一数组
print(b)

c = np.full((2,2),7)                 # 2×2常量数组，运行结果是‘7’而不是‘7.’
print(c)

d = np.eye(2)                        # 2×2单位数组
print(d)

e = np.random.random((2,2))          # 2×2随机数组，范围为[0,1]
print(e)

运行结果

[[ 0.  0.]
 [ 0.  0.]]

[[ 1.  1.]]

[[7 7]
 [7 7]]

[[ 1.  0.]
 [ 0.  1.]]

[[ 0.75674195  0.00198805]
 [ 0.0375324   0.72334415]]

---

数组索引

  Numpy提供了几种索引数组的方法。

切片

  类似于Python中的列表List，可以将numpy数组进行切片。如果是多维数组，需要为数组的每个维度指定一个切片。

import numpy as np

a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
b = a[:2,1:3]

print(a)
print(b)

print(a[0,1])                        # 第一行第二个 
b[0,0] = 77                          # a、b共用同一数据
print(a[0,1])

a[0,1] = 60                          # 改变a或b，都会改动另一方，类似C++中引用
print(b[0,0])

运行结果

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

[[2 3]
 [6 7]]

2

77

60

整型索引与切片索引混合

  这个做法会产生比原始数组更低级的数组。

import numpy as np

a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

row_r1 = a[1,:]                      # 产生一维数组     
row_r2 = a[1:2,:]                    # 产生二维数组
print(row_r1,row_r1.shape)
print(row_r2,row_r2.shape)

col_r1 = a[:,1]
col_r2 = a[:,1:2]
print(col_r1,col_r1.shape)
print(col_r2,col_r2.shape)

运行结果

[5 6 7 8] (4,)

[[5 6 7 8]] (1, 4)

[ 2  6 10] (3,)

[[ 2]
 [ 6]
 [10]] (3, 1)

整数数组索引

  当对numpy数组使用切片索引时，生成的数组将始终是原始数组的子数组。而整数数组索引则允许使用另一个数组的数据构造任意的数组。

import numpy as np

a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])

print(a[[0,1,2],[0,1,0]])                      # 行、列
print(np.array([a[0,0],a[1,1],a[2,0]]))        # 每个的坐标

b = np.array([0,2,0,1])
print(a[np.arange(4),b])

a[np.arange(4),b] += 10  
print(a)    

运行结果

[1 5 7]

[1 5 7]

[ 1  6  7 11]

[[11  2  3]
 [ 4  5 16]
 [17  8  9]
 [10 21 12]]

布尔数组索引

  布尔数组索引可挑选出一个数组的任意元素。通常，这种类型的索引用于选择满足某些条件的数组的元素。

import numpy as np

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

bool_idx = (a > 2)                             # 逐个比较  
print(bool_idx)

print(a[bool_idx])
print(a[a > 2])

运行结果

[[False False]
 [ True  True]
 [ True  True]]

[3 4 5 6]

[3 4 5 6]

---

数据类型

import numpy as np

x = np.array([1,2])                            # int64
print(x,x.dtype)

x = np.array([1.0,2.0])                        # float64
print(x,x.dtype)

x = np.array([1.5,2.8],dtype = np.int64)       # 强制转换，int64
print(x,x.dtype)

运行结果

[1 2] int32

[ 1.  2.] float64

[1 2] int64

---

数组计算

  数组可以进行基本的数学函数计算，并且可以作为操作符重载和在numpy模块中的函数。

import numpy as np

x = np.array([[1,2],[3,4]],dtype = np.float64)
y = np.array([[5,6],[7,8]],dtype = np.float64)

print(x + y)                             # 加法
print(np.add(x,y))

print(x - y)                             # 减法
print(np.subtract(x,y))

print(x * y)                             # 乘法
print(np.multiply(x,y))

print(x / y)                             # 除法
print(np.divide(x,y))

print(np.sqrt(x))                         # 开方


print(np.sum(x))                          # 所有元素相加
print(np.sum(x,axis = 0))                 # 列向量相加
print(np.sum(x,axis = 1))                 # 行向量相加

v = np.array([9,10])
w = np.array([11,12])

print(x.T)                                # 多维数组转置
print(v.T)                                # 一维数组转置不发生改变

print(v.dot(w))                           # 计算内积
print(np.dot(v,w))
print(np.dot(x,v))
print(np.dot(x,y))

运行结果

[[  6.   8.]                              # 加法 
 [ 10.  12.]]
[[  6.   8.]
 [ 10.  12.]]

[[-4. -4.]                                # 减法
 [-4. -4.]]
[[-4. -4.]
 [-4. -4.]]

[[  5.  12.]                              # 乘法
 [ 21.  32.]]
[[  5.  12.]
 [ 21.  32.]]

[[ 0.2         0.33333333]                # 除法
 [ 0.42857143  0.5       ]]
[[ 0.2         0.33333333]
 [ 0.42857143  0.5       ]]

[[ 1.          1.41421356]                # 开方
 [ 1.73205081  2.        ]]

10.0                                      # 所有元素相加

[ 4.  6.]                                 # 列向量相加

[ 3.  7.]                                 # 行向量相加

[[ 1.  3.]                                # 多维数组转置
 [ 2.  4.]]

[ 9 10]                                   # 一维数组转置不发生改变

219                                       # 计算内积v.dot(w)

219                                       # 计算内积np.dot(v,w)

[ 29.  67.]                               # 计算内积np.dot(x,v)

[[ 19.  22.]                              # 计算内积np.dot(x,y)
 [ 43.  50.]]

---

Broadcasting

  Broadcasting广播机制是Python中一种强大的机制，它允许numpy在执行算术运算时使用不同形状的数组。当对一个较小的数组和一个较大的数组进行运算时，通过多次使用较小的数组来对较大的数组执行一些操作。

import numpy as np

x = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v = np.array([1,0,1])

y_empty = np.empty_like(x)                     # 创建一个与x大小相同的空矩阵
for i in range(4):
    y_empty[i,:] = x[i,:] + v;
print(y_empty)

vv = np.tile(v,(4,1))                          # 将v垂直地堆叠起来，形成新数组vv，比上一种方法运行速度快
print(vv)
y_tile = x + vv
print(y_tile)

y_bc = x + v                                   # 传播机制BoardCasting
print(y_bc)

运行结果

[[ 2  2  4]                                   # y_empty
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

[[1 0 1]                                      # vv
 [1 0 1]
 [1 0 1]
 [1 0 1]]

[[ 2  2  4]                                   # y_tile
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

[[ 2  2  4]                                   # y_bc
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

---