numpy

numpy是python用于实现数据科学计算的数据包，以矩阵为基础的数学计算模块，纯数学存储和处理大型矩阵。

import numpy as np
from numpy import pi

data = np.arange(15).reshape(3, 5)

# 返回矩阵的行和列数
print(data.shape)

# 数组的维度
print(data.ndim)

# 数组中元素对象的类型
print(data.dtype)

# 数组中元素的个数
print(data.size)

# 如果矩阵量很大它会将中间部分用省略号省略
a = np.arange(10000).reshape(100,100)
print(a)
# 取消省略号的行为
np.set_printoptions(threshold=np.nan)
b = np.arange(10000).reshape(100,100)
print(b)


def f(x,y):
    return 10*x+y
c = np.fromfunction(f,(5,4),dtype=int)
print(c)
print(c[:, 1])


d = np.array( [[[  0,  1,  2],               # a 3D array (two stacked 2D arrays)
                 [ 10, 12, 13]],
                [[100,101,102],
                 [110,112,113]]])
for elem in d.flat:
    print(elem)
y = np.zeros((2, 3, 4))
print(y)

# 向下取整
e = np.floor(10*np.random.random((3,4)))
print(e)

# 转置矩阵
print(e.T)

# 逆矩阵
e6 = np.mat([
    [1, 1],
    [1, -1]
])
print(e6.I)

# 返回2列6行矩阵
print(e.reshape(6, 2))
f = np.floor(10*np.random.random((3,4)))

# 矩阵合并
print(np.vstack((e, f))) #6行4列
print(np.hstack((e, f))) #3行8列

# 将一位数组变成二组数组，如果本就是二维数组效果和hstack一样
print(np.column_stack((e, f)))
f1 = np.column_stack((np.array([4, 2]), np.array([3, 6])))
print(f1)

from numpy import newaxis
f2 = np.array([3, 4, 6])
print(f2)

# 将一位数组转变成二维数组
print(f2[:, newaxis])

# 以行为标准和以列为标准生成矩阵
print(np.r_[1:4,0,4])
print(np.c_[np.array([1,2,3]), np.array([4,5,6])])
from pprint import pprint

f3 = np.floor(10*np.random.random((2,12)))

# 可以通过指定要返回的等形状数组的数量，或者通过指定在其中发生除法的列来将数组沿水平轴拆分
# 将f3拆分成三个数组
pprint(np.hsplit(f3, 3))

f4 = np.arange(12)
print(f4)

# 浅拷贝
# 不同的数组对象可以共享相同的数据。View方法创建一个新的数组对象，该对象查看相同的数据。
e1 = f4.view()
print(e1)
print(e1 is f4) # False
print(e1.base is f4) # True

# 深拷贝
e2 = f4.copy()
print(e2)
print(e2 is f4)
print(e2.base is f4)
print(f4)
e2[0] = 9999
print(f4)

'''
x = np.array([[1, 2], [3, 4]])
# 将二维数组解释为矩阵
m = np.mat(x)
m1 = np.asmatrix(x)
x[0, 0] = 5
print(m)
print(m1)
'''
# 矩阵相乘
h1 = np.array([[1, 2], [3, 4]])
h2 = np.array([[4, 3, 5], [2, 1, 7]])
r1 = np.dot(h1, h2)
print(r1)

# 花式索引
'''
1，花式索引的索引值是一个数组，对于二维被索引数据来说，索引值可以是一维或者二维。

2，花式索引生成一个新的数组，不像切片，花式索引生成的是新的数据对象。

3，花式索引的索引值为一维数组的时候，索引出数组相应的行，然后拼接成一个新的二维数组。

4，花式索引的索引值为两个维度相同的一维数组凑成的二维向量时，以两个维度作为纵横坐标索引出单值后组合成新的一维向量。

5，由于花式索引不同于切片，实现的是拷贝功能，生成的新数组改变不会影响元数据。
'''
# h3 = np.arange(12)**2
h3 = np.floor(10*np.random.random((7, 10)))
i = np.array([2, 1, 4, 6, 2]) #数字指代矩阵的行索引，如果为一维数组则是起索引值
i1 = np.array([[2, 1], [4, 5]]) # 数字指代矩阵的行索引
print(h3)
print(111111111111111111111111)
print(h3[i])
print(h3[i1]) # 返回一个三位数组

time = np.linspace(20, 145, 5)
datas = np.sin(np.arange(20)).reshape(5, 4)
print(time)
print()
print(datas)

# 浅拷贝
c11 = np.arange(12)
# View方法创建一个新的数组对象，该对象查看相同的数据。
v1 = c11.view()
c11.shape = 3, 4
v1.shape = 2, 6
print(a)
print(c11)
# 会修改a矩阵的数据
c11[0, 4] = 123 # c的第一行的第4个索引位
print(a)
# 取c11中间两列，然后将其替换为1000
s = c11[:, 1:3]
s[:] = 1000
print(c11)
# 深拷贝
v11 = c11.copy()
print(v11.base is c11)
a11 = np.arange(5)
a11[[0, 1, 2]] += 1
a11[[0, 1, 1]] += 1
print(a11)
a12 = np.arange(12).reshape(3, 4)
# 3行4列的二维数组也是矩阵
print(a12)
# 将索引4以上的对应的值变成True其余的为False，返回布尔值矩阵
b12 = a12 > 4
print(b12)
# 根据布尔索引取索引值为4以上的元素，返回一个一维数组
print(a12[b12])
# 将索引值大于4的值修改为0
a12[b12] = 0
print(a12)
import matplotlib.pyplot as plt

'''
def mandelbrot(h, w, maxit=20):
    y, x = np.ogrid[-1.4:1.4:h*1j, -2:0.8:w*1j]
    c = x+y*1j
    z = c
    divtime = maxit+np.zeros(z.shape, dtype=int)
    for i in range(maxit):
        z = z**2+c
        diverge = z*np.conj(z) > 2 ** 2
        div_now = diverge & (divtime == maxit)
        divtime[div_now] = i
        z[diverge] = 2
    return divtime
plt.imshow(mandelbrot(400, 400))
plt.show()
'''
# 注意，1D布尔数组的长度必须与要切片的维度（或轴）的长度重合。
# 比如a12是一个3行4列的矩阵，b13就有3个布尔值，b14有4个布尔值
b13 = np.array([False, True, True])
b14 = np.array([True, False, True, False])
print(a12)
# 取矩阵a12第二行及以后的所有行
print(a12[b13, :])
# 与上一行结果一样
print(a12[b13])
# 取矩阵a12第一列和第三列数据
print(a12[:, b14])
# 分别取a12第二行第一列和第三行第三列的数
print(a12[b13, b14])