numpy&pandas&matplotlib

视频出处

numpy

import numpy as np
# 创建numpy矩阵
array = np.array([[1,2,3],
                  [2,3,4]])
print(array)
print('number of dimensions' + array.ndim)  #维度是几维
print('shape' + array.shape)               #几行几列的
print('size' + array.size)                  #元素个数
"""
[[1 2 3]
 [2 3 4]]
number of dimensions 2
shape (2, 3)
size 6

进程已结束,退出代码0

"""

---

# 矩阵的数字的类型
import numpy as np
a = np.array([2,23,4], dtype = int32) #dtype = float64 一般而言 数字越大内存越大

# 生成全0矩阵，定义shape几行几列。shape要用括号括起来
a = np.zeros((3,4)) # 生成3行4列的全零矩阵

# 生成全部非常接近0的矩阵
a = np.empty((3,4))


# 生成range数列
a = np.arrange(10,20,2) # 10~20，步长为2

# 生成range，再reshape成别的矩阵
a = np.arange(12).reshape((3,4))
"""
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
"""

# 生成线段
a = np.linspace(1,10,5) # 1 10分别代表a的首尾，再从中间取5-2个数字
# 这个也可以reshape
a = np.linspace(1,10,5).reshape((3,4))


#################################################



import numpy as np

a = np.arange(2, 14).reshape(3, 4)
print(a)
print(np.argmin(a))    #求a矩阵中最小元素的索引
print(np.argmax(a))     #求a矩阵中最大元素的索引

# 求a的平均值的两种方法
print(a.mean())
print(np.mean(a))

print(np.cumsum(a))     # 返回前缀和矩阵
print(np.diff(a))       # 返回后一个减去前一个的差值
print(np.nonzero(a))    # 返回两个数组，分别表示非零元素的行和列
print(np.sort(a))       # 一行一行的排序

# 求矩阵A的转置的两种方法
print(a.T)
print(np.transpose(a))

print(a.T.dot(a))     # 求A的转置 * A

print(np.clip(a, 5, 9))   # 将矩阵a小于5的数全部变成5，大于9的数全部变成9
print(np.mean(a, axis=0))    # axis=0按列求和，返回一个行向量
print(np.mean(a, axis=1))    # axis=1按行求和，返回一个列向量

print("\n\n")
# numpy的按下标索引
A = np.arange(3, 15).reshape((3, 4))
print(A)
print(A[0][0], A[0, 0])      # 都返回A[0][0]这个元素
print(A[:, 2])              # 返回第3列所有数

print(A.flatten())    # 展平成一个向量
print(A.flat)       # A.flat 返回一个迭代器 迭代A的所有元素
for item in A.flat:
    print(item, end=" ")
print()

# numpy中数组的合并
A = np.array([1, 1, 1])
B = np.array([2, 2, 2])
C = np.vstack((A, B))    # vertical stack
D = np.hstack((A, B))    # horizontal stack
print(A.shape, C.shape, D.shape)

# 将numpy数组的一行元素变为一列
# 此时A为一个行向量
print(A, A.shape)       # [1 1 1] (3,)
A = A[np.newaxis, :]    # A本来是一个一维的三个数，在行加上一维，变成(1, 3)
print(A, A.shape)       # [[1 1 1]] (1, 3)
A = A[:, np.newaxis]     # 此时的A未经过上面一步 A[np.newaxis, :]
print(A, A.shape)       # A本来是一个一维的三个数，在列加上一维，变成(3, 1)
"""
此时print(A, A.shape)为
[[1]
 [1]
 [1]] (3, 1)
"""
A = np.array([1, 1, 1])
C = np.concatenate((A, B), axis=0)
print("C=", C)

A = np.array([1, 1, 1])[:, np.newaxis]      # 此时A B 的shape都是(3, 1)
B = np.array([2, 2, 2])[:, np.newaxis]
C = np.concatenate((A, B), axis=1)          # 将A B合并为C。axis=0表示对行操作， 上下纵向按行堆叠。axis=1表示对列操作，横向左右按列堆叠
print("C=", C)
print("\n\n\n")

# numpy的分割
A = np.arange(1, 13).reshape(3, 4)
B = np.split(A, 2, axis=1)      # axis=1表示按列分割
print(B)            # 本来是一个3行4列的，按列分割成2个3行2列的矩阵，此时的分割必须分割的矩阵个数相等
# 如果想要不等的分割，可以用array_split
B = np.array_split(A, 3, axis=1)
print(B)            # 本来是一个3行4列的，按列axis=1分割成1个2列的，1个1列的，1个1列的
# 按照horizonal split和 vertical split分割
print("A.shape=", A.shape)
print(np.vsplit(A, 3))      # 沿着垂直方向（行方向）进行分割
print(np.hsplit(A, 4))      # 沿着水平方向（列方向）进行分割

# copy & deep copy
A = np.arange(4, dtype=float)
# A[0] = 0.02     # 要想把这个数改成小数，需要设置矩阵的数字类型为float
print(A)
B = A   # D B A 都指向同一个矩阵，此时不论修改哪一个，都会影响到其他两个
D = B
# 要想实现将A的值给B而不是将A B都指向一个矩阵，需要用到copy函数
B = A.copy()    # 此时修改B不会修改到A

pandas

import pandas as  pd
import numpy as np
s = pd.Series([1,3,6,np.nan,44,1])      # 创建np的列表 ；类型为float64
print(s)

dates = pd.date_range('20160101', periods=6)
print(dates)

# DataFrame是一个大的矩阵，类似于numpy的
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=['a', 'b', 'c', 'd'])    # index表示行 columns表示列 randn生成标准正态分布的伪随机数，均值为0，方差为1
print(df)
print(df.loc['2016-01-01', 'a'])    # 按下标访问
print(df.index)     # 打印行的索引
print(df.columns)   # 打印列的索引
print(df.describe())

##########################################################
# pandas 选择数据 对数字筛选
date = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.arange(24).reshape(6, 4), index=date, columns=['A', 'B', 'C', 'D'])
print("原数据为：\n------------------\n", df, "\n---------------------------\n")
print("df['A']= \n", df['A'], "\ndf.A= ", df.A)     # 按照行或列访问。
print("df[0:3]=\n", df[0:3])        # DataFrame的切片 [a:b] 是取[a,b), 默认是对行切片
print("df['20130102':'20130104']=\n", df['20130102':'20130104'])    # DataFrame的切片 按照下表切片
# 更高级的方法： select by label: loc 按照标签来索引，即按照index和colums来索引
print(df.loc['20130102'])       # 选择一行的标签打印
print(df.loc[:, 'A'])           # 选择一列的标签打印
print(df.loc[:, ['A', 'B']])    # 选择两列的标签打印
# 打印特定的需求的数据：
print(df.loc['20130102', ['A', 'B']])

# select by position 按第几位来选择 iloc
print(df.iloc[1])           # 输出第三行的数据
print(df.iloc[3, 1])        # 输出第三行第一列的数据 下标从0开始
print(df.iloc[2:4, 1:3])    # 按照切片的方法来输出
print(df.iloc[[1, 3, 5], 1:3])    # 按照不连续的方式取出


# Boolean indexing
print(df)
print(df[df.A > 8])

##########################################################
# pandas设置值 更改之
df.iloc[1, 1] = 11111   # 按照下标更改值
df.loc['20130103', 'C'] = 465468
# df['20130103', 'C'] = 465468  不知道是干嘛的，新增了一列
print(df)

df[df > 9] = 0  # 将df矩阵中比9大的数字全部变成0
df[df > 9] = 0 等价于 df[df.A > 9] = 0

df.A[df.A > 9] = 0  # 将df.A(等价于df['A']) 中比大于9的全部变成0
df['F'] = np.nan    # 新增一列，全为nan

# 新增一行序列，保证行的索引与原索引一致
df['E'] = pd.Series([1, 2, 3, 4, 5, 6], index=df.index)
print(df)


##########################################################
# 处理丢失数据 对于nan的处理
df = pd.DataFrame(np.arange(24).reshape(6, 4), index=date, columns=['A', 'B', 'C', 'D'], dtype=int)    # 重新生成数据
df.iloc[0, 1] = np.nan
df.iloc[1, 2] = np.nan
print(df)

# 将有nan的删除。axis=0表示行有则删除行。axis=1表示列有则删除列。how是指定删除的条件。默认为any，只要有nan则删除该行或列。也可以是'all', 表示全部为nan才删除该行或列
print(df.dropna(axis=0, how='any'))

# 将nan填充为别的数字，使用fillna
print(df.fillna(value=0))

# 返回一个矩阵判断是否有nan，对于矩阵特别大自己看不出来
# np.any()中有任一个的意思，df.isnull()是一个矩阵，对每个数是否为nan返回一个矩阵
print(df.isnull())
print(np.any(df.isnull()) == True)


# pandas导入到处数据
data = pd.read_csv(r'E:\EdgeDownloads\student.csv')
print(data)


# pandas合并 concat
# concatenating
df1 = pd.DataFrame(np.ones((3, 4))*0, columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.ones((3, 4))*1, columns=['a', 'b', 'c', 'd'])
df3 = pd.DataFrame(np.ones((3, 4))*2, columns=['a', 'b', 'c', 'd'])
print(df1, '\n', df2, '\n', df3)
# 上下合并df1 2 3
# ignore_index表示将原来的行号删除，重新设定行号
res1 = pd.concat([df1, df2, df3], axis=0, ignore_index=True)    #axis=0表示按行合并，往下合并. ignore_index表示将原来的行号删除，重新设定行号
print("上下合并df1 df2的结果：\n", res1)

# 左右合并df1 2 3
res2 = pd.concat([df1, df2, df3], axis=1)   #axis=1表示按列合并，往右合并
print("左右合并df1 df2的结果:\n", res2)


# join功能：为concat的一个参数，有两种形式['inner', 'outer']
# concat的join功能默认为outer模式。将一个矩阵有，一个没有的的数据保存，并将没有的矩阵的位置设为nan
# 如果是inner模式，则默认将公共的部分保留，不重合的部分裁切掉。
df1 = pd.DataFrame(np.ones((3, 4))*0, index=[1, 2, 3], columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.ones((3, 4))*1, index=[2, 3, 4], columns=['b', 'c', 'd', 'e'])
res = pd.concat([df1, df2], join='inner', ignore_index=True)
print(res)


# append 一个矩阵
df1 = pd.DataFrame(np.ones((3, 4))*0, columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.ones((3, 4))*1, columns=['a', 'b', 'c', 'd'])
df3 = pd.DataFrame(np.ones((3, 4))*1, columns=['b', 'c', 'd', 'e'], index=[2, 3, 4])

res = df1.append(df2, ignore_index=True)    # 忽略原来的行号，重新写
print(res)
res = df1.append([df2, df3])    # 要同时处理多个矩阵时，将多个矩阵用中括号放一起。[df2, df3]
print(res)


# append一个向量
df1 = pd.DataFrame(np.ones((3, 4))*0, columns=['a', 'b', 'c', 'd'])
s1 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
res = df1.append(s1, ignore_index=True)
print("df1=\n", df1, "\ns1=\n", s1, "\nres=\n", res)


# 通过merge合并DataFrame

# merge two df by key/keys (may be used in database)
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                     'A': ['A0', 'A1', 'A2', 'A3'],
                     'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
print(left)
print(right)
res = pd.merge(left, right, on='key')       # 基于key来merge
print(res)

# consider two keys
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                             'key2': ['K0', 'K1', 'K0', 'K1'],
                             'A': ['A0', 'A1', 'A2', 'A3'],
                             'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                              'key2': ['K0', 'K0', 'K0', 'K0'],
                              'C': ['C0', 'C1', 'C2', 'C3'],
                              'D': ['D0', 'D1', 'D2', 'D3']})
print(left)
print(right)
# merge合并方式默认的how是inner，取交集。
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')  # default for how='inner'
# how有多种方式，还可以按照某个DataFrame来实现 : how = ['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
"""
  key1 key2   A   B
0   K0   K0  A0  B0
1   K0   K1  A1  B1
2   K1   K0  A2  B2
3   K2   K1  A3  B3
  key1 key2   C   D
0   K0   K0  C0  D0
1   K1   K0  C1  D1
2   K1   K0  C2  D2
3   K2   K0  C3  D3
  key1 key2   A   B    C    D
0   K0   K0  A0  B0   C0   D0
1   K0   K1  A1  B1  NaN  NaN
2   K1   K0  A2  B2   C1   D1
3   K1   K0  A2  B2   C2   D2
4   K2   K1  A3  B3  NaN  NaN
"""


# indicator
# indicator说明合并是哪一个DataFrame有数据。明确的说出来
df1 = pd.DataFrame({'col1': [0, 1], 'col_left': ['a', 'b']})
df2 = pd.DataFrame({'col1': [1, 2, 2], 'col_right': [2, 2, 2]})
print(df1)
print(df2)
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)    #将df1 df2按照col1的序列来排序。
print(res)
# give the indicator a custom name
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')  # 执行indicator的名字从_merge改为指定值
print(res)


# merged by index
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                           'B': ['B0', 'B1', 'B2']},
                           index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                            'D': ['D0', 'D2', 'D3']},
                             index=['K0', 'K2', 'K3'])
print(left)
print(right)
# left_index and right_index
# left_index 将左侧的行索引用作其连接键
# right_index 将右侧的行索引用作其连接键
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')  # 将left和right的行索引取并集
print(res)
"""
      A    B    C    D
K0   A0   B0   C0   D0
K1   A1   B1  NaN  NaN
K2   A2   B2   C2   D2
K3  NaN  NaN   C3   D3

"""
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')  # 将left和right的行索引取交集
print(res)
"""
     A   B   C   D
K0  A0  B0  C0  D0
K2  A2  B2  C2  D2

"""


# handle overlapping
# 将boys和girls按k合并，将不同DataFrame中相同的参数加上不同的后缀表示是不同的。
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
print(res)
"""
    k  age_boy  age_girl
0  K0        1         4
1  K0        1         5
"""


# pandas的plot画图~
import matplotlib.pyplot as plt

# Series的画图 Series表示一个线性的数据。一个向量
data = pd.Series(np.random.randn(1000), index=np.arange(1000))     # randn生成标准正态分布的伪随机数(均值为0，方差为1)
data = data.cumsum()    # 前缀和
data.plot()             # 画图
plt.show()              # 显示

# DataFrame的绘图
data = pd.DataFrame(np.random.randn(1000, 4),
                    index=np.arange(1000),
                    columns=list("ABCD"))   # list("ABCD") 表示生成一个列表['A', 'B', 'C', 'D']
data = data.cumsum()    # 前缀和
data.plot()
"""
plot methods:
'bar', 'hist', 'box', 'kde', 'area', 'scatter', 'hexbin', 'pie'
"""
# plt.scatter(x=, y=)
ax = data.plot.scatter(x='A', y='B', color='DarkBlue', label='Class 1')
data.plot.scatter(x='A', y='C', color='DarkGreen', label='Class 2', ax=ax)  # ax参数用于指定绘图所在的坐标轴（Axes）
# ax=ax应该是指定画的这两个图为同一个坐标轴。指定了两个散点在一个图上画。不指定则在两个图上画
plt.show()

matplotlib

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.gridspec as gridspec
from matplotlib import animation

# 基本用法
x = np.linspace(-1, 1, 50)
y = 2*x+1
plt.plot(x,y)
plt.show()      # 展示图片


# figure图像
x = np.linspace(-3, 3, 50)
y1 = 2*x+1
y2 = x**2
plt.figure()
plt.plot(x, y1)
# plt.show()

plt.figure(num=3, figsize=(20, 10))    # plt.figure是另开一张图，下面所有的语句都在这张图上展示
plt.plot(x, y2, color='red', linewidth=1.0, linestyle='--')          # 画第一条线
plt.plot(x, y1, color='green', linewidth=2.0, linestyle='dotted')  # 画第二条线

# 设置坐标轴范围
plt.xlim((-1, 2))   # 设置x坐标轴显示范围
plt.ylim((-2, 3))   # 设置y坐标轴显示范围

# 设置坐标轴标签
plt.xlabel('I am x', fontsize=20)
plt.ylabel('I am y', fontsize=20)

# 替换x轴的显示范围区间
new_ticks = np.linspace(-1, 2, 5)
print(new_ticks)
plt.xticks(new_ticks)
plt.yticks([-2, -1.8, -1, 1.2, 2],
           [r'$really\ bad$', '$bad$', r'$normal$', r'$good$', r'$very\ good$'])    # 加上$会变成好看的字体。此时空格前也需要一个转义符


# 设置边框颜色
# gca = 'get current axis'
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))


# Legend 图例
plt.figure()
l1, = plt.plot(x, y1, label='up')
l2, = plt.plot(x, y2, color='red', linewidth=1, linestyle='--', label='down')
plt.legend(handles=[l1, l2, ],labels=['y1', 'y2'], loc='best')  # 在这里再用labels就不用之前设定的labels


# Annotation注释

# 方法一
x0 = 1
y0 = 2*x0+1
plt.scatter(x0, y0, s=50, color='b')
plt.plot([x0, x0], [y0, -6], 'k--', lw=2)
plt.annotate(r'$2x+1=%s$'%y0, xy=(x0, y0), xycoords='data', xytext=(+30, -30), textcoords='offset points',
             fontsize=16, arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=.2'))
"""
annotate()用于在图形中添加一个注释
%s 和 %y0是占位符，用于在文本中插入变量的值
xy=(x0, y0)指定了注释箭头所指向的位置的坐标
xycoords='data' 表示xy坐标是基于数据坐标系的。xycoords 参数可以接受不同的值来指定注释中 xy 坐标的参考坐标系
可以用data， offset points，figure fraction，offset points
xytext=(+30, -30)指定了注释文本的位置偏移，其中+30是在x正方向偏移30个点，-30表示在y负方向上偏移30个点
textcoords='offset points' 表示 xytext 坐标是基于偏移点的坐标系。
arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=.2') 用于指定注释箭头的样式，
其中 arrowstyle='->' 表示箭头样式为一个朝向注释文本的箭头，
connectionstyle='arc3,rad=.2' 表示箭头与注释文本之间的连接线采用弧形。
"""

# 方法二
plt.text(-3.7, 3, r'$This\ is\ some\ text,\ \mu\ \sigma_i\ \alpha^t$',
         fontdict={'size':16, "color":'g '})
plt.show()


# tick能见度
x = np.linspace(-3, 3, 50)
y = 0.1*x

plt.figure()
plt.plot(x, y, linewidth=10, zorder=1)      # set zorder for ordering the plot in plt 2.0.2 or higher
plt.ylim(-2, 2)
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data', 0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data', 0))

# 坐标轴数值的label
for label in ax.get_xticklabels() + ax.get_yticklabels():
    label.set_fontsize(12)
    label.set_bbox(dict(facecolor='white', edgecolor='None', alpha=0.7))
    # facecolor是填充色，edgecolor是边缘线条的颜色，alpha表示坐标轴的透光程度是70%， 底下30%的颜色可以透过坐标轴的label
plt.show()

# 散点图 scatter
n = 1024
X = np.random.normal(0, 1, n)  # 平均值0，方差为1
Y = np.random.normal(0, 1, n)
T = np.arctan2(Y, X)        # for color value 不用深入研究
plt.scatter(X, Y, c=T, alpha=0.5)   # c表示color。alpha表示透明度
plt.xlim((-1.5, 1.5))   # 设置x坐标的显示范围
plt.ylim((-1.5, 1.5))   # 设置y坐标的显示范围
plt.xticks(())          # 设置x坐标为null 删除x轴
plt.yticks(())          # 设置y坐标为null 删除y轴
plt.show()


# bar柱状图
n = 12
X = np.arange(n)
Y1 = (1 - X/float(n)) * np.random.uniform(0.5, 1.0, n)
Y2 = (1 - X/float(n)) * np.random.uniform(0.5, 1.0, n)

plt.bar(X, Y1, facecolor='#9999ff', edgecolor='white')
plt.bar(X, -Y2, facecolor='#ff9999', edgecolor='white')
# 将边框全部清除
# gca = 'get current axis'
ax = plt.gca()
ax.spines['right'].set_color('none')    # 边框设置为none 全部清除
ax.spines['top'].set_color('none')
ax.spines['bottom'].set_color('none')
ax.spines['left'].set_color('none')
"""
zip是将多个元组打包，可以同时得到多个元组中的元素
"""
for x, y in zip(X, Y1):
    plt.text(x, y+0.05, '%.2f' % y, ha='center', va='bottom')   # ha:horizontal alignment
for x, y in zip(X, Y2):
    plt.text(x, -y-0.05, '%.2f' %y, ha='center', va='top')

plt.xlim(-.5, n)    # 设置x轴显示范围 xlim
plt.xticks(())      # 删除x轴
plt.ylim(-1.25, 1.25)
plt.yticks(())      # 删除y轴

plt.show()


# contours 等高线图

# the height function:
def f(x, y):
    return (1 - x / 2 + x**5 + y**3) * np.exp(-x**2 - y**2)

n = 256
x = np.linspace(-3, 3, n)   # linspace 默认是50个
y = np.linspace(-3, 3, n)
X, Y = np.meshgrid(x, y)    # 生成网格矩阵
Z = f(X, Y)     # Z 表示等高线的高度

# use plt.contourf to filling contours
# X, Y and value for (X, Y) point
plt.contourf(X, Y, Z, 8, alpha=0.8, cmap=plt.cm.rainbow)    # 8表示等高线区分的区域，0会有2个区域，8有10个区域。cmap是color map，采用彩虹

# use plt.contour to add contour lines
C = plt.contour(X, Y, Z, 8, colors='black',)
# adding label
plt.clabel(C, inline=True, fontsize=10)   # 添加文字，inline表示文字区域不显示线

# 删除x y坐标轴
plt.xticks(())
plt.yticks(())

plt.show()


# Image 图片
# image data
a = np.array([0.313660827978, 0.365348418405, 0.423733120134,
              0.365348418405, 0.439599930621, 0.525083754405,
              0.423733120134, 0.525083754405, 0.651536351379]).reshape(3,3)
"""
for the value of "interpolation", check this:
http://matplotlib.org/examples/images_contours_and_fields/interpolation_methods.html
for the value of "origin"= ['upper', 'lower'], check this:
http://matplotlib.org/examples/pylab_examples/image_origin.html
"""
plt.imshow(a, interpolation='nearest', cmap='bone', origin='lower')
plt.colorbar(shrink=0.5)    # shrink表示colorbar的长度缩水多少

plt.xticks(())
plt.yticks(())
plt.show()


# 3D图片
fig = plt.figure()
ax = Axes3D(fig, auto_add_to_figure=False)
fig.add_axes(ax)
# X, Y value
x = np.arange(-4, 4, 0.25)
y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
# height value
Z = np.sin(R)
# 画3D图的方式：ax.plot_surface
# rstride表示row的网格的密集程度。 cstride表示column网格的密集程度 cmap是colormap
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=plt.get_cmap('rainbow'))
# zdir表示从z轴向下投影。offset=-2表示投影到z=-2的位置。
ax.contourf(X, Y, Z, zdir='z', offset=-2, cmap='rainbow')
ax.set_zlim3d(-2, 2)
plt.show()

# subplot多合一显示
plt.figure()
plt.subplot(211)    # 表示一共2行1列，画在第1个位置上
plt.plot([0, 1], [0, 1])
plt.subplot(234)    # 此行一共3列，上面一张图占了3列，所以下面第一个从4开始
plt.plot([0, 1], [1, 0])
plt.subplot(235)
plt.plot([-1, 0], [0, 1])
plt.subplot(2,3,6)
plt.plot([-1, 0], [0, -1])
plt.show()


# subplot分隔显示

# method 1: subplot2grid
plt.figure()
# (3, 3)是所有网格的行数和列数，(0, 0)代表起始位置，colspan和rowspan表示列和行的跨度
ax1 = plt.subplot2grid((3, 3), (0, 0), colspan=3, rowspan=1)
ax1.plot([1, 2], [1, 2])
ax1.set_title('ax1 title')
ax2 = plt.subplot2grid((3, 3), (1, 0), colspan=2)   # 默认rowspan是1
ax3 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)   # 默认colspan是1
ax4 = plt.subplot2grid((3, 3), (2, 0))
ax5 = plt.subplot2grid((3, 3), (2, 1))
plt.show()

# method 2:gridspec:
plt.figure()
gs = gridspec.GridSpec(3, 3)     # 定义3行3列的gridspace
ax1 = plt.subplot(gs[0, :])
ax1.plot([0, 1], [0, 1])    # 在ax1上画图
ax1.set_title('ax1_title')
ax2 = plt.subplot(gs[1, :2])
ax3 = plt.subplot(gs[1:, 2])
ax4 = plt.subplot(gs[2, 0])
ax5 = plt.subplot(gs[2, 1])
plt.show()

# method 3: easy to defin structure  不学了！！！！！！
f, ()plt.subplots(2, 2, sharex=True, sharey=True)    # 共享x y轴都为True


# 画中画
fig = plt.figure()
x = [1,2,3,4,5,6,7]
y = [1,3,4,2,5,8,6]
"""
left：子图左侧边界相对于整个图形的左侧的位置，以浮点数表示，取值范围为 [0, 1]。
bottom：子图底部边界相对于整个图形的底部的位置，以浮点数表示，取值范围为 [0, 1]。
width：子图的宽度相对于整个图形的宽度的比例，以浮点数表示，取值范围为 [0, 1]。
height：子图的高度相对于整个图形的高度的比例，以浮点数表示，取值范围为 [0, 1]。
"""
left, bottom, width, height = 0.1, 0.1, .8, .8
ax1 = fig.add_axes([left, bottom, width, height])
ax1.plot(x, y, 'r')
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_title('title')

left, bottom, width, height = 0.2, 0.6, 0.25, 0.25
ax2 = fig.add_axes([left, bottom, width, height])
ax2.plot(x, y, 'b')
ax2.set_xlabel('x')
ax2.set_ylabel('y')
ax2.set_title('title inside 1')


plt.axes([.6, .2, .25, .25])
plt.plot(y[::-1], x, 'g')   # y[::-1] 表示将序列逆序 不会修改原来的序列
plt.xlabel('x')
plt.ylabel('y')
plt.title('title inside 2')
plt.show()


# 主次坐标轴
x = np.arange(0, 10, .1)
y1 = 0.05*x**2
y2 = -y1

fig, ax1 = plt.subplots()
ax2 = ax1.twinx()       # 将ax1反转    有twinx和twiny
ax1.plot(x, y1, 'g-')   # green -表示实线
ax2.plot(x, y2, 'b--')  # -- 表示虚线
ax1.set_xlabel('X data')
ax1.set_ylabel('Y1', color='g')
ax2.set_ylabel('Y2', color='b')
plt.show()
"""
主次坐标轴案例
import matplotlib.pyplot as plt

# 创建主坐标轴
fig, ax1 = plt.subplots()

# 绘制主坐标轴的数据
x = [1, 2, 3, 4, 5]
y1 = [10, 20, 15, 25, 30]
ax1.plot(x, y1, 'b-', label='Primary Axis')

# 设置主坐标轴标签和标题
ax1.set_xlabel('X-axis')
ax1.set_ylabel('Primary Y-axis')
ax1.set_title('Primary and Secondary Axes')

# 创建次坐标轴
ax2 = ax1.twinx()

# 绘制次坐标轴的数据
y2 = [0.1, 0.2, 0.15, 0.25, 0.3]
ax2.plot(x, y2, 'r--', label='Secondary Axis')

# 设置次坐标轴标签
ax2.set_ylabel('Secondary Y-axis')

# 显示图例
ax1.legend(loc='upper left')
ax2.legend(loc='upper right')

# 显示图形
plt.show()
"""


# Animation动画
# from matplotlib import animation
"""
plt.subplots()返回一个包含图形对象和子图对象的元组 (fig, ax)。
fig 是图形对象，可以用于设置图形的整体属性，例如标题、尺寸等。
ax 是一个子图对象或子图对象数组，可以用于绘制和操作子图。

plt.subplots() 函数的常用参数包括：
    nrows：子图的行数，默认为 1。
    ncols：子图的列数，默认为 1。
    sharex：如果为 True，则所有子图共享相同的 x 轴，默认为 False。
    sharey：如果为 True，则所有子图共享相同的 y 轴，默认为 False。
    squeeze：如果为 True，则当只有一个子图时，返回的子图对象不是数组，而是单个对象，默认为 True。
    subplot_kw：用于传递给 add_subplot() 方法的关键字参数的字典。
    gridspec_kw：用于传递给 GridSpec 构造函数的关键字参数的字典。
"""

fig, ax = plt.subplots()
x = np.arange(0, 2*np.pi, 0.01)
line, = ax.plot(x, np.sin(x))       # ,是用于解包

def animate(i):
    line.set_ydata(np.sin(x+i/10))
    return line,

def init():
    line.set_ydata(np.sin(x))
    return line,

ani = animation.FuncAnimation(fig=fig, func=animate, frames=100, init_func=init, interval=20, blit=True)
plt.show()