北理工Numpy数据分析及展示系列视频（学习记录）

沃若_Ronze

已于 2023-08-31 10:30:02 修改

阅读量51

点赞数

文章标签： numpy 数据分析学习 matplotlib

于 2023-08-27 22:42:51 首次发布

本文链接：https://blog.csdn.net/qq_57352551/article/details/132528230

版权

一、Numpy库入门

import numpy as np
# a = np.array([[0,1,2,3,4],
              # [9,8,7,6,5]])
# print(a)
# print(a.ndim)   # a.ndim 表示 a 数组的维度数，即 a 数组的秩。
# print(a.shape)
# print(a.size)
# print(a.dtype)      # int 32
# print(a.itemsize)   # 4 每个元素由四个字节构成

# x = np.array([0,1,2,3])             # 列表
# y = np.array((1,2,3,4))             # 元组
# z = ([[1,2],[9,8],(0.1,0.2)])       # 个数相同，即可混用
# print(x)
# print(y)
# print(z)

# print(np.arange(5))     # 元素从0到n-1
# print(np.ones(3))       # np.ones(shape)生成全1的数组，shape是数组类型形状,如：(2,3,4)
# print(np.zeros((3,6),dtype=np.int32))      # np.ones(shape)生成全0的数组，shape是数组类型形状,dtype=指定类型
# print(np.full(6,2))     # np.full(shape,val)生成全val的数组，shape是数组类型形状
# print(np.eye((4),dtype=np.int32))        # 创建n*n的单位对角矩阵，对角线为1，其余为0
#
# print(np.ones((2,3,4)))

# np.ones_like(a)       # 根据数组a的形状生成一个全1数组
# np.zeros_like(a)       # 根据数组a的形状生成一个全0数组
# np.full_like(a,val)       # 根据数组a的形状生成一个数组,每个元素值都是val

# np.linspace(,endpoint=False)         # 根据起止数据等间距填充数据形成数组,endpoint=False最后一个数不出现
# np.concatenate()      # 将两个或多个数组合并成一个新数组
# a = np.linspace(1,10,4)
# print(a)
# b = np.linspace(1,10,4,endpoint=False)
# print(b)
# print(np.concatenate((a,b)))        # 注意括号数

# ndarray数组的维度变换
# .reshape(shape)     # 不改变数组元素，返回一个shape形状的数组，原数组不变
# .resize(shape)     # 与.reshape()功能一致，但修改原数组
# .swapaxes(ax1,ax2)      # 将数组n个维度中两个维度进行调换
# .flatten        # 对数组进行降维，返回折叠后的一维数组，原数组不变

# a = np.ones((2,3,4),dtype=np.int32)
# print(a)
# print(a.reshape((3,8)))
# print(a)
# print(a)
# print(a.resize((3,8)))      # None
# print(a)

# print(a.flatten())
# print(a)

# ndarray数组类型的变换
# new_a = a.astype(new_type)
# a = np.ones((2,3,4),dtype=np.int64)
# print(a)
# b = a.astype(np.float32)        # .astype()方法会创建新的数组
# print(b)

# ndarray数组向列表转换
# Is = a.tolist()

# a = np.full((2,3,4),25,dtype=np.int32)
# print(a)
# print(type(a))
# b = a.tolist()
# print(b)
# print(type(b))

# 数组的索引和切片
# a = np.array([9,8,7,6,5])
# print(a[2])
# print(a[1:4:2])     # 起始，终止，步长
# 多维
# a = np.arange(24).reshape((2,3,4))
# print(a)
# print(a[1,2,3])     # 正数每一维度都从0开始
# print(a[0,2,3])
# print(a[-1,-2,-3])      # 负数每一维度都从-1开始
# print(a[ :,1,-3])
# print(a[:,1:3,:])
# print(a[:,:,::2])         # 每个维度可以使用步长跳跃

# 数组与标量的运算：每一个数都运算
# a = np.arange(24).reshape((2,3,4))
# print(a.mean())
# print(a.mean)

# print(a/a.mean())

# numpy一元函数：
# np.abs(x)np.fabs(x)     # 计算各元素绝对值
# np.sqrt(x)              # 计算各元素平方根
# np.square(x)            # 计算各元素平方
# np.log(x)np.log10(x)    # 计算各元素自然对数、10底对数和2底对数
# np.ceil(x)np.floor(x)   # 计算各元素的ceiling值或floor值
# np.rint(x)              # 对元素四舍五入
# np.modf(x)              # 将各元素的小数和整数以独立数组形式返回(先小后整）
# np.cos(x)np.cosh(x)     # 计算各元素的普通型和双曲型三角函数
# np.sin(x)np.sinh(x)     # 计算各元素的普通型和双曲型三角函数
# np.tan(x)np.tanh(x)# 计算各元素的普通型和双曲型三角函数
# np.exp(x)               # 计算各元素的指数值
# np.sign(x)              # 计算各元素的符号值，1（+),0-1(-)

# a = np.arange(24).reshape((2,3,4))
# print(a)
# print(np.square(a))
# print(a)
# print(np.sqrt(a))
# print(a)
# print(np.modf(a))
# print(a)

# numpy二元函数：
# +-*/:           # 两个数组各元素进行对应运算
# np.maximum(x,y)np.fmax()        # 元素的最大值/最小值运算
# np.minimum(x,y)np.fmin()        # 元素的最大值/最小值运算
# np.mod()                        # 元素的模运算
# np.copysign(x,y)                # 将数组y中各元素的符号赋值给数组x对应的元素
# > < >= <= == !=                 # 算数比较，产生布尔型数组
#
# a = np.arange(24).reshape((2,3,4))
# b = np.sqrt(a)
# # print(a)
# # print(b)
# print(np.maximum(a,b))
# print(a > b)

二、数据的存取及多种函数


# csv文件
# 写入.csv文件
# np.savetxt(frame,array,fmt='%.18e',delimiter=None)
# frame:文件、字符串或产生器，可以是.gz或.bz的压缩文件。
# array:存入文件的数组。
# fmt:写入文件的格式，例如：%d %.2f %.18e
# delimiter:分割字符串，默认为逗号

# a = np.arange(100).reshape(5,20)
# # print(a)
# # 这个代码将数组a中的每个元素转换为浮点数，并将它们以逗号分隔的形式保存为一个CSV文件
# np.savetxt('a.csv',a,fmt='%d',delimiter=',')

# 读取.csv文件
# np.loadtxt(frame,dtype=np.float,delimiter=None,unpack=False)
# frame:文件、字符串或产生器，可以是.gz或.bz的压缩文件。
# dtype:数据类型，可选     最新版本pycharm中不用np.
# delimiter:分割字符串，默认为空格
# unpack:如果是True,读入属性将分别写入不同变量
# b = np.loadtxt('a.csv',delimiter=',')
# print(b)
# c = np.loadtxt('a.csv',dtype=int,delimiter=',')
# print(c)

# csv的局限性：只能有限存储一维和二维数组

# 多维数组的存取
# a.tofile(frame,sep='',format='%s')        # 写
# frame:文件、字符串
# sep:数据分割字符串，如果是空串，写入文件为二进制
# format：写入数据的格式

# a = np.arange(100).reshape(5,10,2)
# # a.tofile("b.dat",sep=",",format='%d')
# a.tofile("b.dat",format='%d')

# np.fromfile(frame,dtype=np.float,count=-1,sep='')         # 取
# frame:文件、字符串
# dtype:读取的数据类型
# count:读入元素的个数，-1表示读入整个文件
# sep:数据分割字符串，如果是空串，写入文件为二进制

# a = np.arange(100).reshape(5,10,2)
# a.tofile("b.dat",sep=",",format='%d')
# c = np.fromfile("b.dat",dtype=int,sep=",")
# print(c)
# c = np.fromfile("b.dat",dtype=int,sep=",").reshape(5,10,2)
# print(c)
# a = np.arange(100).reshape(5,10,2)
# a.tofile("b.dat",format='%d')
# c = np.fromfile("b.dat",dtype=int).reshape(5,10,2)
# print(c)

# a.tofile()和np.arange()配合使用，需要知道存入文件时的维度和元素类型
# 可以通过元数据文件来存储额外信息

# Numpy的便捷文件存取
# np.save(frame,array)或np.savez(fname,array)
# frame:文件名，以.npy为扩展名,压缩扩展名为.npz
# array:数组变量
#
# np.load(fname)
# frame:frame:文件名，以.npy为扩展名,压缩扩展名为.npz
# a = np.arange(100).reshape(5,10,2)
# np.save('a.npy',a)
# b = np.load('a.npy')
# print(b)

# Numpy的随机数函数子库
# (1)
# random子库  np.random.*
# rand(d0,d1,...dn)       # 根据d0-d1创建随机数数组，浮点数[0,1],均匀分布
# randn(d0,d1,...dn)      # 根据d0-d1创建随机数数组,均匀分布
# randint(low[,high,shape])      # 根据shape创建随机整数或整数数组，范围是[low,high]
# seed(s)     随机数种子，s是给定的种子值

# a = np.random.rand(3,4,5)
# print(a)
# b = np.random.randn(3,4,5)
# print(b)
# c = np.random.randint(100,200,(3,4))
# print(c)
#
# np.random.seed(10)
# c = np.random.randint(100,200,(3,4))
# print(c)
# np.random.seed(10)
# c = np.random.randint(100,200,(3,4))
# print(c)
# (2)
# shuffle(a):         # 根据数组a的第一轴进行随排列，改变数组x(不会返回新数组)
# permutation(a):     # 根据数组a的第一轴产生新的乱序数组，不改变数组x
# choice(a[,size,replace,p])       # 从以为数组a中以概率p抽取元素，形成size形状新数组,replace表示是否可以重用元素，默认是False(可以重复）
#
# a = np.random.randint(100,200,(3,4))
# print(a)
# # np.random.shuffle(a)
# # print(a)
# b = np.random.permutation(a)
# print(a)
# print(b)

# b = np.random.randint(100,200,(8,))
# print(b)
# c = np.random.choice(b,(3,2),replace=False)
# print(c)
# d = np.random.choice(b,(3,2),replace=False,p = b/np.sum(b))
# print(d)
# (3)
# uniform(low,high,size)      # 产生均匀分布的数组，low起始值，high结束值，size形状
# normal(loc,scale,size)      # 产生正态分布的数组，loc均值，scale标准差，size形状
# poisson(lam,size)           # 产生泊松分布的数组，lam随机事件发生率，size形状
#
# u = np.random.uniform(0,10,(3,4))
# print(u)
#
# n = np.random.uniform(10,5,(3,4))
# print(n)

# w = np.random.poisson(3,(3,4))
# print(w)

# Numpy的统计函数
# （1）
# sum(a,axis=None)    # 根据给定轴axis计算数组a相关元素之和，axis整数或元组
# mean(a,axis=None)   # 根据给定轴axis计算数组a相关元素的期望，axis整数或元组
# average(a,axis=None,weights=None)   #  根据给定轴axis计算数组a相关元素的加权平均值
# std(a,axis=None)    # 根据给定轴axis计算数组a相关元素的标准差
# var(a,axis=None)    # 根据给定轴axis计算数组a相关元素的方差
#
# a = np.arange(15).reshape(3,5)
# print(a)
# print(np.sum(a))
# print(np.mean(a,axis=0))
# print(np.mean(a,axis=1))    # 将数组a沿着第1个轴（即行方向）进行求和，然后将求和结果除以数组a的长度，即计算平均值
# print(np.average(a,axis=0,weights=[10,5,1]))
# print(np.average(a,axis=1,weights=[1,1,1,1,1]))     # 权重给列，按行方向求值
# print(np.std(a))
# print(np.var(a))
#(2)
# min(a) max(a)            # 计算数组a中元素的最小值、最大值
# argmin(a) argmax(a)     # 计算数组a中元素的最小值、最大值的降一维后下标
# unravel_index(index,shape)  # 根据shape将一维下标index(argmin(a)或argmax(a))转化成多维下标
# ptp(a)                  # 计算数组a中最大值和最小值的差
# median(a)               # 计算数组a中元素的中位数（中值）
# b = np.arange(15,0,-1).reshape(3,5)
# print(b)
# print(np.max(b))
# print(np.argmax(b))             # 扁平化后的下标
# print(np.unravel_index(np.argmax(b),b.shape))       # 重塑成多维下标
# print(np.ptp(b))
# print(np.median(b))             # 运算
#
# numpy的梯度函数
# np.gradient(f)      计算数组f中元素的梯度，当f为多维时，返回每个维度梯度:梯度：(后-前）/2，单侧有值时用本身，且不除2

# a = np.random.randint(0,20,(5))
# print(a)
# print(np.gradient(a))

# 二维数组求梯度得到两个数组，第一个是外层的梯度，即对列求梯度，第二个是第二层的梯度，即对行求梯度
# a = np.random.randint(0,50,(3,5))
# print(a)
# print(np.gradient(a))

# c = np.random.randint(0,50,(2,3,5))
# print(c)
# print(np.gradient(c))

三、图像及Matplotlib

from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
# Image是PIL库中代表一个图像的类(对象)
# 图像是一个三维数组，维度分别是高度、宽度和像素RGB值
# im = np.array(Image.open("D:\\桌面\Desktop\\测试.png"))
# print(im.shape,im.dtype)        # 输出表示图像的形状为(高度,宽度,通道数)，数据类型为uint8
# a = np.array(Image.open("D:\\桌面\Desktop\\测试.png"))
# print(a.shape,a.dtype)
# print(a)
# b = [255,255,255] - a
# im = Image.fromarray(b.astype('uint8'))
# im.save("D:\\桌面\Desktop\\测试1.png")

# a = np.array(Image.open("D:\\桌面\Desktop\\测试.png").convert('L'))
# # print(a)
# b = 255 - a
# im = Image.fromarray(b.astype('uint8'))
# im.save("D:\\桌面\Desktop\\测试2.png")

# a = np.array(Image.open("D:\\桌面\Desktop\\测试.png").convert('L'))
# c = (100/255)*a + 150
# im = Image.fromarray(c.astype('uint8'))
# im.save("D:\\桌面\Desktop\\测试3.png")
#
# a = np.array(Image.open("D:\\桌面\Desktop\\测试.png").convert('L'))
# d = 255*(a/255)**2  # 像素平方
# im = Image.fromarray(d.astype('uint8'))
# im.save("D:\\桌面\Desktop\\测试4.png")
#
# # 手绘风格
# a = np.asarray(Image.open("D:\\桌面\Desktop\\测试.png").convert('L')).astype('float')
#
# depth = 10                              # (0-100)
# grad = np.gradient(a)                   # 取图像灰度的梯度值
# grad_x,grad_y = grad                    # 分别取横纵图像梯度值
# grad_x = grad_x*depth/100.
# grad_y = grad_y*depth/100.
# A = np.sqrt(grad_x**2 + grad_y**2+1.)
# uni_x = grad_x/A
# uni_y = grad_y/A
# uni_z = 1./A
#
# vec_el = np.pi/2.2
# vec_az = np.pi/4.
# dx = np.cos(vec_el)*np.cos(vec_az)
# dy = np.cos(vec_el)*np.sin(vec_az)
# dz = np.sin(vec_el)
#
# b = 255*(dx*uni_x + dy*uni_y + dz*uni_z)    # 光源归一化
# b = b.clip(0,255)                           # 灰度值裁剪至0-255区间
#
# im = Image.fromarray(b.astype('uint8'))     # 重构图像
# im.save("D:\\桌面\Desktop\\测试5.png")

# matplotlib库
# matplotlib.pyplot是绘制各类可视化图形的命令子库
# import matplotlib.pyplot as plt # 引入别名
# plt.plot([3,1,4,5,2])            # 数据
# plt.ylabel("grade")
# plt.savefig('text',dpi=600)     # 生成文件，后一个参数控制质量
# plt.show()

# plt.plot([0,2,4,6,8],[3,1,4,5,2])
# plt.ylabel("grade")
# plt.axis([-1,10,0,6])       # 控制x,y轴的定义域和值域
# plt.show()

# pyplot的绘图区域
# plt.subplot(nrows,ncols,plot_number)      # 分区域，并定位到一个子绘图区域(横、纵、第几个)
#
# def f(t):
#     return np.exp(-t) * np.cos(2*np.pi*t)
# a = np.arange(0.0,5.0,0.02)
# plt.subplot(211)
# plt.plot(a,f(a))
#
# plt.subplot(212)
# plt.plot(a,np.cos(2*np.pi*a),'r--')
# plt.show()

# plt.plot(x,y,format_string,**kwargs)
# x:X轴数据，列表或数组，可选
# y:Y轴数据，列表或数组
# format_string:控制曲线的格式的字符串，可选
# **kwargs:第二组或更多(x,y,format_string)
# 绘制多条曲线时，各条曲线的x不能省略

# a = np.arange(10)
# plt.plot(a,a*1.5,'g-o',a,a*2.5,'rv-',a,a*3.5,a,a*4.5)
# plt.show()

# format_string:控制曲线的格式字符串，可选，由颜色字符，风格字符和标记字符组成
# 颜色： b:蓝色    g：绿色    r:红色    c:青绿色   m:洋红色   y:黄色    k:黑色    w:白色
# '#008000':RGB某颜色        '0.8'：灰度值字符串
# 风格：'-' '--' '-.' ':' ''''''无线条
# 格式字符串：'.'',''o''v''^''>''<''1''2''3''4''s''p''h''H''+''x''D''d''|'
# color：控制颜色，color='green'
# linestyle:线条风格，linestyle='dashed'
# marker：标记风格，marker='o'
# markerfacefolor:标记颜色，markerfacefolor='blue'

# pyplot的中文显示：第一种方法，需要rcParams修改字体
# 'font.family' ：显示字体名字     'SimHei''Kaiti''LiSu''FangSong''YouYuan''STSong'
# 'font.style' :字体风格 正常:'normal'，斜体:'italic'
# 'font.size':字体大小，整数字号或者'large'，'x-small'

import matplotlib
# matplotlib.rcParams['font.family']='SimHei'     # 黑体
# plt.plot([3,1,4,5,2])
# plt.ylabel("纵轴（值）")
# plt.savefig('tesst',dpi=600)
# plt.show()

# matplotlib.rcParams['font.family'] = 'STSong'
# matplotlib.rcParams['font.size'] = 20
# a = np.arange(0.0,5.0,0.02)
# plt.xlabel('横轴：时间')
# plt.ylabel('纵轴：振幅')
# plt.plot(a,np.cos(2*np.pi*a),'r--')
# plt.show()

# pyplot的中文显示：第二种方法：增加一个属性：fontproperties

# a = np.arange(0.0,5.0,0.02)
# plt.xlabel('横轴：时间',fontproperties='SimHei',fontsize=20)
# plt.ylabel('纵轴：振幅',fontproperties='SimHei',fontsize=20)
#
# plt.plot(a,np.cos(2*np.pi*a),'r--')
# plt.show()
#
# pyplot的文本显示函数
# plt.xlabel():对x轴增加文本标签
# plt.ylabel():对y轴增加文本标签
# plt.title():对图形整体增加文本标签
# plt.text()：在任意位置增加文本
# plt.annotate()：在图形中增加带箭头的注释
#
# a = np.arange(0.0,5.0,0.02)
# plt.plot(a,np.cos(2*np.pi*a),'r--')
# plt.xlabel('横轴：时间',fontproperties='SimHei',fontsize=15,color='green')
# plt.ylabel('纵轴：振幅',fontproperties='SimHei',fontsize=15)
# plt.title(r'正弦波实例$y=cos(2\pi x)$',fontproperties='SimHei',fontsize=20)
# plt.text(2,1,r'$\mu=100$',fontsize=15)      # 2,1是标注的起始坐标
# plt.axis([-1,6,-2,2])
# plt.grid(True)  # 显示网格
# plt.show()
#
# a = np.arange(0.0,5.0,0.02)
# plt.plot(a,np.cos(2*np.pi*a),'r--')
# plt.xlabel('横轴：时间',fontproperties='SimHei',fontsize=15,color='green')
# plt.ylabel('纵轴：振幅',fontproperties='SimHei',fontsize=15)
# plt.title(r'正弦波实例$y=cos(2\pi x)$',fontproperties='SimHei',fontsize=20)
# plt.annotate(r'$\mu=100$',xy=(2,1),xytext=(3,1.5),arrowprops=dict(facecolor='black',shrink=0.1,width=2))
# plt.axis([-1,6,-2,2])
# plt.grid(True)  # 显示网格
# plt.show()

# plt.subplot2grid(Gridpec,CurSpec,colspan=1,rowpan=1)      (3,3)(0,0) colspan横轴占用区域个数,rowpan纵轴占用区域个数
# 设定网格，选中网格，确定选中行列区域数量，编号从零开始
# plt.subplot2grid((3,3),(0,0),colspan=3)
# plt.subplot2grid((3,3),(1,0),colspan=2)
# plt.subplot2grid((3,3),(1,2),colspan=2)
# plt.subplot2grid((3,3),(2,0))
# plt.subplot2grid((3,3),(2,1))
#
# GridSpec类
# 有冒号则后一个数字指定的不算，没冒号时则为指定的行和列
# import matplotlib.gridspec as gridspec
# gs = gridspec.GridSpec(3.3)     # 划分为3*3的网格，调用时先横后竖
# ax1 = plt.subplot(gs[0,:])
# ax2 = plt.subplot(gs[1,:-1])
# ax3 = plt.subplot(gs[1:,-1])
# ax4 = plt.subplot(gs[2,0])
# ax5 = plt.subplot(gs[2,1])
#

# pyplot基础图标函数
# plt.plot(x,y,fmt,...)           # 绘制一个坐标图
# plt.boxplot(data,notch,position)     # 绘制一个箱形图
# plt.bar(left,height,width,bottom)     # 绘制一个条形图
# plt.barh(width,bottom,left,height)     # 绘制一个横向条形图
# plt.polar(theat,r)     # 绘制一个极坐标图
# plt.pie(data,explode)     # 绘制一个饼图
# plt.psd(x,NFFT=256,pad_to,Fs)           # 绘制功率谱密度图
# plt.specgram(x,NFFT=256,pad_to,Fs)      # 绘制谱图
# plt.cohere(x,y,NFFT=256,Fs)             # 绘制X-Y的相关性函数
# plt.scatter(x,y)                        # 绘制散点图，其中，x和y长度相同
# plt.step(x,y,where)                     # 绘制步阶图
# plt.hist(x,bins,normed)                 # 绘制直方图
# plt.contour(X,Y,Z,N)                    # 绘制等值图
# plt.vlines()                            # 绘制垂直图
# plt.stem(x,y,linefmt,markerfmt)         # 绘制柴火图
# plt.plot_date()                         # 绘制数据日期
# 饼图绘制
# labels = 'Frogs','Hogs','Dogs','Logs'
# sizes = [15,30,45,10]
# explode = (0,0.1,0,0)
# plt.pie(sizes,explode=explode,labels=labels,autopct='%1.1f%%',shadow=True,startangle=0)
# plt.axis('equal')
# plt.show()
# 直方图绘制
# np.random.seed(0)
# mu,sigma = 100,20       # 均值和标准差
# a = np.random.normal(mu,sigma,size=100)
# # plt.hist(a,10,normed=1,histtype='stepfilled',facecolor='b',alpha=0.75)       # 10:直方图个数
# plt.title("Histogram")
# plt.hist(a, 10, density=True, histtype='stepfilled', facecolor='b', alpha=0.75)     # normed=1功能已取消
# plt.show()

# np.random.seed(0)
# mu,sigma = 100,20       # 均值和标准差
# a = np.random.normal(mu,sigma,size=100)
# plt.hist(a, 40, density=True, histtype='stepfilled', facecolor='b', alpha=0.75)
# plt.title("Histogram")
# plt.show()

# 面向对象绘制极坐标图
# N = 20              # 绘制坐标的个数
# theta = np.linspace(0.0,2*np.pi,N,endpoint=False)
# radii = 10*np.random.rand(N)
# width = np.pi/4*np.random.rand(N)
#
# ax = plt.subplot(111,projection='polar')
# bars = ax.bar(theta,radii,width=width,bottom=0.0)
# # left height width
# for r,bar in zip(radii,bars):
#     bar.set_facecolor(plt.cm.viridis(r/10.))
#     bar.set_alpha(0.5)
#
# plt.show()

# N = 10             # 绘制坐标的个数
# theta = np.linspace(0.0,2*np.pi,N,endpoint=False)
# radii = 10*np.random.rand(N)
# width = np.pi/2*np.random.rand(N)
#
# ax = plt.subplot(111,projection='polar')
# bars = ax.bar(theta,radii,width=width,bottom=0.0)
# # left height width
# for r,bar in zip(radii,bars):
#     bar.set_facecolor(plt.cm.viridis(r/10.))
#     bar.set_alpha(0.5)
#
# plt.show()

# 散点图
# fig,ax = plt.subplots()
# ax.plot(10*np.random.randn(100),10*np.random.randn(100),'o')
# ax.set_title('Simple Scatter')
#
# plt.show()

四、Pandas库


# pandas
# pandas是Python第三方库，提供高性能易用数据类型和分析工具,基于Numpy实现，常与matplotlib一同使用
# import pandas as pd
#
# d = pd.Series(range(20))
# print(d)
# print(d.cumsum())

# 两个数据类型：Series ,DataFrame
# 基于上述数据类型的各类操作
# 基本、运算、特征类、关联类操作

# Series类型由一组数据及与之相关的数据索引组成
# index_0     data_a
# index_1     data_b
# index_2     data_c
# index_3     data_d
# 索引          数据

# a = pd.Series([9,8,7,6])
# print(a)
# b = pd.Series([9,8,7,6],index=['a','b','c','d'])        # 自定义索引
# print(b)

# Series类型可以由如下类型创建：Python列表  标量值 Python字典    ndarray     其他函数
# 标量值创建
# s = pd.Series(25,index=['a','b','c'])        # Python列表
# s = pd.Series(25,index=range(5))             # 拓展
# print(s)
# d = pd.Series({'a':9,'b':8})                 # Python字典
# print(d)
# e = pd.Series({'a':9,'b':8},index=['c','b','d'])
# print(e)
# n = pd.Series(np.arange(5))
# print(n)
# m = pd.Series(np.arange(5),index=np.arange(9,4,-1))
# print(m)

# Series类型的基本操作
# Series类型包括index和values两部分
# Series类型的操作类似ndarray类型
# Series类型的操作类似Python字典类型

# b = pd.Series([9,8,7,6],['a','b','c','d'])
# print(b)
# print(b.index)          #.index获得索引
# print(b.values)         #.values获得数据
# print(b['b'])
# print(b[[0,1]])
# print(b[['c','d']])
# print(b[['c','d',0]])      # 报错，两套索引不能混用

# b = pd.Series([9,8,7,6],['a','b','c','d'])
# print(b)
# print(b[3])             # 值
# print(b[:3])            # 索引 + 值
#
# print(b[b > b.median()])
# print(np.exp(b))

# Series类型的基本操作
# 类似Python字典类型
# 通过自定义索引访问
# 保留字in操作
# 使用.get方法
# b = pd.Series([9,8,7,6],['a','b','c','d'])
# print(b['b'])
# print('c'in b)
# print(0 in b)
# print(b.get('f',100))   # 有f则返回对应值，无f返回100
# print(b.get('a',100))   # 有f则返回对应值，无f返回100

# Series类型的对其操作
# a = pd.Series([1,2,3],['c','d','e'])
# b = pd.Series([9,8,7,6],['a','b','c','d'])      基于索引计算，没有的为NaN
# print(a + b)

# name属性

# b = pd.Series([9,8,7,6],['a','b','c','d'])
# b.name = 'Series对象'
# b.index.name = '索引词'
# print(b.name)
# print(b)
# b['a'] = 15
# b.name = 'Series'
# b['b','c'] = [20,20]      报错：pandas.errors.IndexingError: Too many indexers
# print(b)


# DataFrame类型(表格型，可表达多维）

# index_0     data_a  data_1  data_w
# index_1     data_b  data_2  data_x
# index_2     data_c  data_3  data_y
# index_3     data_d  data_4  data_z
# 纵轴为index 索引axis = 0       横轴为column   索引axis = 1
# 可由以下类型创建：二维ndarray对象，由以为ndarray、列表、字典、元组或Series构成的字典，其他的DataFrame类型
# 二维ndarray对象
# d = pd.DataFrame(np.arange(10).reshape(2,5))
# print(d)        # 自动添加行索引和列索引
# dt = {'one':pd.Series([1,2,3],index=['a','b','c']),
#       'two':pd.Series([9,8,7,6],index=['a','b','c','d'])}
# d = pd.DataFrame(dt)
# print(d)
# e = pd.DataFrame(dt,index=['b','c','d'],columns=['two','three'])    # 数据根据行列索引自动补齐，columns是列名
# print(e)
# 从列表类型的字典创建
# dl = {'one':[1,2,3,4],'two':[9,8,7,6]}
# d = pd.DataFrame(dl,index = ['a','b','c','d'])
# print(d)
# dl = {'城市':['北京','上海','广州','深圳','沈阳'],
#       '环比':[101.5,101.2,101.3,102.0,100.1],
#       '同比':[120.7,127.3,119.4,140.9,101.4],
#       '定基':[121.4,127.8,20.0,145.5,101.6]}
# d = pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
# print(d)
#
# print(d['同比'])
# print(d.loc['c1'])      # ix已不可用，使用loc[]
# print(d['同比']['c1'])
# DataFrame是二维带标签的数组
# DataFrame基本操作类似Series,依据行列索引

# 如何改变Series和DataFrame对象？
# 增加或重排：重新索引      删除：drop

# .reindex()能够改变或重排Series和DataFrame索引
# dl = {'城市':['北京','上海','广州','深圳','沈阳'],
#       '环比':[101.5,101.2,101.3,102.0,100.1],
#       '同比':[120.7,127.3,119.4,140.9,101.4],
#       '定基':[121.4,127.8,20.0,145.5,101.6]}
# d = pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
# print(d)
# d = d.reindex(index=['c5','c2','c3','c4','c1'])     # 重排行
# print(d)
# d = d.reindex(columns=['城市','同比','环比','定基'])        # 重排列
# print(d)
# .reindex(index=None,columns=None,...)的参数
# index,columns:新的行列自定义索引
# fill_value:重新索引中，用于填充缺失位置的值
# method:填充方法，ffill当前值向前填充，bfill向后填充
# limit:最大填充量
# copy:默认True，生成新的对象，False时，新旧相等不复制

# newc = d.columns.insert(4,'新增')     # 第5列
# print(newc)
# newd = d.reindex(columns=newc,fill_value=200)
# print(newd)
# print(newd.index)       # 获取行名称
# print(newd.columns)         # 获取列名称

# 索引类型的常用方法
# .append(idx):连接另一个Index对象，产生新的Index对象
# .diff(idx): 计算差集，产生新的Index对象
# .intersection(idx): 计算交集
# .union(idx):计算并集
# .delect(loc):删除loc位置处的元素
# .insert(loc,e)在loc位置处增加一个元素e

# dl = {'城市':['北京','上海','广州','深圳','沈阳'],
#       '环比':[101.5,101.2,101.3,102.0,100.1],
#       '同比':[120.7,127.3,119.4,140.9,101.4],
#       '定基':[121.4,127.8,20.0,145.5,101.6]}
# d = pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
# print(d)
# nc= d.columns.delete(3)            # 删除横轴索引名并返回剩余的
# print(nc)
# print(d)
# ni = d.index.insert(5,'c6')
# print(ni)
# print(d)
# nd = d.reindex(index=ni,method='ffill')
      # nd = d.reindex(index=ni,columns=nc,method='ffill')        # 视频中原代码，会报错
# print(nd)
# nc= nd.columns.delete(3)            # 删除横轴索引名并返回剩余的
# print(nc)
# print(d)

# 删除指定索引对象
# .drop能够删除Series和DataFrame指定行或列索引
# a = pd.Series([9,8,7,6],index=['a','b','c','d'])
# print(a)
# print(a.drop(['a','c']))
# dl = {'城市':['北京','上海','广州','深圳','沈阳'],
#       '环比':[101.5,101.2,101.3,102.0,100.1],
#       '同比':[120.7,127.3,119.4,140.9,101.4],
#       '定基':[121.4,127.8,20.0,145.5,101.6]}
# d = pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
# print(d)
# print(d.drop('c5',axis=0))          # axis=0删除横轴元素，默认为0，可省略
# print(d.drop('同比',axis=1))          # # axis=1删除纵轴元素，axis=1不可省略

# pandas的运算
# 根据行列索引，补齐后运算，默认产生浮点数
# 补齐时缺项填充NaN(空值)
# 不同维之间为广播运算，一维Series默认在轴1参与运算
# 采用+-*/符号进行的二元运算产生新的对象

# a = pd.DataFrame(np.arange(12).reshape(3,4))
# b = pd.DataFrame(np.arange(20).reshape(4,5))
# print(a)
# print(b)
# print(a + b)
# +-*/对应的方法：.add(d,**argws)   .sub(d,**argws)     .mul(d,**argws)   .div(d,**argws)

# a = pd.DataFrame(np.arange(12).reshape(3,4))
# b = pd.DataFrame(np.arange(20).reshape(4,5))
# print(b.add(a,fill_value = 100))    # fill_value的值代替NaN
# c = pd.Series(np.arange(4))
# print(c-10)
# print(b - c)           # 一维Series默认在轴1参与运算(横轴)
# 可以指定0轴参与运算
# print(b.sub(c,axis=0))
# 比较运算法则
# 只比较相同索引的元素，不进行补齐
# 不同维之间为广播运算
# 使用比较符号，产生布尔对象
# a = pd.DataFrame(np.arange(12).reshape(3,4))
# d = pd.DataFrame(np.arange(12,0,-1).reshape(3,4))
# print(a)
# print(d)
# print(a > d)
# print(a == d)
a = pd.DataFrame(np.arange(12).reshape(3,4))
c = pd.Series(np.arange(4))
print(a > c)                  # 默认在轴1参与运算(横轴)
print(c > 0)

# .sort_index()方法在指定轴上根据索引进行排序，默认升序     默认是在0轴，即索引的列向排序
# .sort_index(axis=0,ascending=True)
# b = pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','b','d'])
# print(b)
# # print(b.sort_index())
# print(b.sort_index(ascending=False))
# c = b.sort_index(axis=1,ascending=False)
# print(c)
# c = c.sort_index()
# print(c)

# .sort_values()方法在指定轴上根据数值进行排序，默认升序
# Series.sort_values(axis=0,ascending=True)
# DataFrame.sort_values(by,axis=0,ascending=True)   by:axis轴上某个索引或索引列表
# b = pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
# print(b)
# c = b.sort_values(3,ascending=False)        # 按第三列数据排序，行中所有元素皆变位置
# print(c)
# d = b.sort_values('c',axis=1,ascending=False)
# print(d)
# 排序是NaN放末尾
# a = pd.DataFrame(np.arange(12).reshape(3,4),index=['a','b','c'])
# b = pd.DataFrame(np.arange(20).reshape(4,5),index=['d','a','b','c',])
# # print(a)
# # print(b)
# c = a + b
# print(c)        # 索引对应的数据进行运算
# d = (c.sort_values(2,ascending=False))      # 空值排序不敏感
# print(d)
# e = (c.sort_values(2,ascending=True))
# print(e)

# 基本的统计分析函数（两种适用）
# .sum():计算数据的总和，按0轴计算，下同
# .count：非NaN值的数量
# .mean() .median()：算数平均值、算数中位数
# .var() .std()：方差、标准差
# .min() .max()：最小值、最大值
# Series适用
# .argmin() .argmax():最大值、最小值所在位置的索引位置（自动索引）
# .idxmin() .idxmin()：最大值、最小值所在位置的索引位置（自定义索引）

# .describ:针对0轴的统计汇总
# a = pd.Series([9,8,7,6],index=['a','b','c','d'])
# print(a)
# print(a.describe())
# print(type(a.describe()))
# print(a.describe()['count'])   # 非NaN值的数量，使用方法是['函数关键字']
# print(a.describe()['max'])        # 最大值

# b = pd.DataFrame(np.arange(20).reshape(4,5),index=['d','a','b','c',])
# print(b.describe())
# print(type(b.describe()))
# 下列代码返回一个包含每列最大值的 Series，其中 Series 的索引是列名
# print(b.describe().loc['max'])      # ix是新版本的属性，可用loc代替就不会报错
# print(b.describe()[2])

# 数据的累计统计分析函数,默认为纵轴方向
# .cumsum():依次给出前1、2、……n数的和
# .cumprod():依次给出前1、2、……n数的积
# .cummax():依次给出前1、2、……n数的最大值
# .cummin:依次给出前1、2、……n数的最小值

# b = pd.DataFrame(np.arange(20).reshape(4,5),index=['d','a','b','c',])
# print(b.cumsum())
# print(b.cumprod())
# print(b.cummax())
# print(b.cummin())

# 滚动计算 默认为纵轴，当前行与上w行
# .rolling(w)sum():依次计算相邻w个元素的和
# .rolling(w)mean():依次计算相邻w个元素的算数平均值
# .rolling(w)vars():依次计算相邻w个元素的方差
# .rolling(w)std():依次计算相邻w个元素的标准差
# .rolling(w)min() max():依次计算相邻w个元素的最大值和最小值

# b = pd.DataFrame(np.arange(20).reshape(4,5),index=['d','a','b','c',])
# print(b)
# print(b.rolling(2).sum())
# print(b.rolling(3).sum())

# 数据的相关分析
# 正相关、负相关、不相关：协方差度量、pearson相关系数
# 相关分析函数
# .cov:计算协方差矩阵
# .corr:计算相关系数矩阵，Person、Spearman、Kendall等系数
# import matplotlib.pyplot as plt
# hpric = pd.Series([3.04,22.93,12.75,22.6,12.33],index=['2008','2009','2010','2011','2012'])
# m2 = pd.Series([8.18,18.38,9.13,7.82,6.69],index=['2008','2009','2010','2011','2012'])
# print(hpric.corr(m2))
# print(hpric.index)
# print(hpric.values)
#
# plt.plot(hpric.index,hpric.values,'g-o',m2.index,m2.values,'bv-')
#
# plt.show()