python科学计算库numpy学习笔记

numpy的基本操作

使用numpy.array()创建数组和矩阵

# -*- coding:utf-8 -*-
import numpy as np


vector = np.array([1, 2, 3, 4, 5, 6, 7])
# np.array类型，输出<class 'numpy.ndarray'>，为numpy中数组特有类型
print(type(vector))

# numpy.array()同样可以用来生成矩阵，注意中括号外还要有一层中括号
matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

print(matrix.shape)       # 输出array的形状

---

切片

切片格式为[start: end: step]，代表从start开始，以end-1结束（左闭右开），步长为step.
ex.输出逆向访问向量vector：print(vector[::-1])

# 单个冒号: 的位置代表行/列全部选中
vector[:]          # 选中向量所有行，和直接print(array)结果相同
vector[::-1]       # 逆向vector
matrix[:, 2]       # 选中矩阵所有行，只取第三列，即[3, 6, 9]
matrix[0:2]        # 矩阵前两行
matrix[0][2]       # 矩阵第0行第2个元素
matrix[0, 2]       # 和上面作用相同

# 下面是对array做切片，和python语句中的list切片同理
# 切片格式为[start: end: step]，起始、终止、步长，起始终止左闭右开

vector[0:]         # 等同于全部array
vector[0::2]       # 每隔2个选一个，结果为[1, 3, 5, 7]

# 一个综合的例子：取矩阵第0行到第1行，同时每隔2个取一列
matrix[0:2, 0::2]  # [[1 3][5 7]]

equal = (vector == 6)
print(equal)              # 依次判断向量每个元素是否为6，返回布尔向量，输出
print(vector[equal])      # 返回所有为True的值，输出

---

查看并转换数据类型

vector.dtype          # 输出array的数据类型
vector.astype(float)  # 将array全部转化为指定数据类型

---

最大值与最小值

vector.max()  # 等价于max(vector)
vector.min()  # 等价于min(vector)

---

求和

matrix.sum(axis=1)    # 按行求和，指定维度axis是1代表行
matrix.sum(axis=0)    # 按列求和，指定维度axis是0代表列

---

numpy常用基本函数

# 下面是numpy常用基本函数
a = np.arange(12)     # 产生0-11的数组成的向量
np.arange(0, 40, 10)  # 从0到40，每隔10产生一个数据，输出为 0,20,30
b = a.reshape(3, 4)   # 将a的形状改为3x4的矩阵

c = np.zeros((3, 4))  # 创建3x4的零矩阵（float型），注意参数为元组！
c = np.ones((3, 4))   # 创建3x4的全一矩阵（float型），参数同样为元组

c = np.zeros((3, 4), dtype=int)  # 创建int型的零矩阵，dtype=要转化的格式
c = np.ones((3, 4), dtype=int)   # 创建int型的全一矩阵

d = np.random.random((2, 3))     # 创建2x3的随机矩阵，值为-1到+1之间

print(np.linspace(0, 2*pi, 100))  # 取0到2π之间等分的100的数

print(np.exp(a))   # e^a
print(np.sqrt(a))  # sqrt(a)

---

矩阵的基本操作

vec1 = np.array([[1, 2], [3, 4]])
vec2 = np.array([[1, 0], [0, 1]])
2*vec1          # 将矩阵的每个元素乘以2
1+vec1          # 将矩阵的每个元素都加一
vec1+vec2       # 两矩阵对应位置相加
vec1*vec2       # 两矩阵对应位置相乘，即Aij * Bij
vec1.dot(vec2)  # 两矩阵实际乘法，也就是前者行乘以后者列，也可写作np.dot(vec1, vec2)

print(vec1.T)   # vec1的转置，很直觉...
# 矩阵A求逆，需要先从numpy.array()转化为numpy.matrix()，再利用A.I求逆
matrix = np.array([[1, 2], [1, 4]])
A = np.matrix(vec1)  # 若A 不满秩则无法求逆，会报错

vec3 = np.hstack((vec1, vec2))  # 横向拼接，纵向拼接为numpy.vstack()
print(np.hsplit(vec3, 2))       # 横向切割为2份，纵向为numpy.vsplit()

print(vec1.argmax(axis=1))   # 按行选最大值并给出最大值的索引，按列axis=0
print(vec1.argsort(axis=1))  # 按行排序并给出顺序给出下标索引的改变
# 例如[4, 3, 2, 1]的argsort返回的结果是[0, 1, 2, 3]

---

浅拷贝与深拷贝

之前学到过，python中的变量的直接赋值均是传递引用。
假设给a与b同时赋值为1，则二者指向的内存单元相同。
但经测试发现，numpy中的array在创建两个相同的向量a和b时：

1. 独立创建两个向量，虽然值相同，但是它们的内存单元不同；
2. 先创建a，再令b=a后，a的内存单元与b的内存单元相同。

上面的第二点也就是说：经过复制后的几个numpy.array指向相同的内存单元，且对一个变量的任何改变都会改变指向的内存单元。

浅拷贝
使用下面的语句创建后，相当于将a浅拷贝给b，此时它们还是共享同一块内存的数据，但是变成了两个分开的变量。（个人觉得可以理解为拷贝的不够彻底）

vec1 = np.array([[1, 2], [3, 4]])
vec2 = vec1.view()  # 浅拷贝语句

print(np.reshape(vec2, (1, 4)))
print(vec1.shape)  # vec1的shape与改变后的vec2的shape不同

vec1[1, 1] = 0
print(vec2)        # 但是将vec1的值做改变后，vec2的值还是跟着变了

深拷贝
最狠的拷贝，让二者只是值相同，剩下的关系撇的干干净净。

vec1 = np.array([[1, 2], [3, 4]])
vec2 = vec1.copy()

---