本文是在观看mooc课堂上的python数据分析展示课堂上记录的笔记，可供学习参考。
1、numpy基础
numpy数组的创建与变换
一维数据：由对等关系的有序或无序数据构成，采用线性方式组织。 例如：列表和集合
数组：数据类型是相同的。
二维数据：由多个一维数据构成，是一维数据的组合形式。 例如：列表嵌套列表
高维数据：仅利用最基本的二元关系展示数据间的复杂结构。 例如：json的键值对数据结构，字典类型。xml，yaml
-
数组的创建方法
1. 从python的列表、元组以及二者混合类型创建 np.array([xxx]) 2. 使用numpy的函数创建ndarray数组 np.arange(n) ：类似range（）函数，返回ndarray类型，元素从0到n-1 np.ones(shape) ：生成一个全1的数组，shape是一个元组类型 np.zeros(shape) ：根据shape生成一个全0数组，shape是元组类型 np.full(shape,val) ：根据shape生成一个数组，每个元素都是val np.eye(n) ：创建一个正方的n*n的单位矩阵，对角线为1，其余为0
import numpy as np
np.arange(20)
》》》array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19])
np.full((5,5),6) #生成5行5列全为6，整数型
》》》array([[6, 6, 6, 6, 6],
[6, 6, 6, 6, 6],
[6, 6, 6, 6, 6],
[6, 6, 6, 6, 6],
[6, 6, 6, 6, 6]])
np.ones((5,5)) #生成的是浮点型
》》》array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
np.zeros((5,5))#生成的是浮点型
》》》array([[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]])
#生成单位矩阵
np.eye(5)#生成的是浮点型
》》》array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
指定数据类型dtype = np.int32
np.empty([2,3])
》》》array([[0., 0., 0.],
[0., 0., 0.]])
np.eye(5,dtype = np.int32)#生成的是整数型
》》》array([[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]])
也可以生成多维数组
np.ones((2,3,4))
》》》array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
生成等差数列
np.linspace(1,50,endpoint = True)# endpoint是指终止值包含
》》》array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13.,
14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.,
27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50.])
#等比数列
np.logspace(1,100)
》》》array([1.00000000e+001, 1.04811313e+003, 1.09854114e+005, 1.15139540e+007,
1.20679264e+009, 1.26485522e+011, 1.32571137e+013, 1.38949549e+015,
1.45634848e+017, 1.52641797e+019, 1.59985872e+021, 1.67683294e+023,
1.75751062e+025, 1.84206997e+027, 1.93069773e+029, 2.02358965e+031,
2.12095089e+033, 2.22299648e+035, 2.32995181e+037, 2.44205309e+039,
2.55954792e+041, 2.68269580e+043, 2.81176870e+045, 2.94705170e+047,
3.08884360e+049, 3.23745754e+051, 3.39322177e+053, 3.55648031e+055,
3.72759372e+057, 3.90693994e+059, 4.09491506e+061, 4.29193426e+063,
4.49843267e+065, 4.71486636e+067, 4.94171336e+069, 5.17947468e+071,
5.42867544e+073, 5.68986603e+075, 5.96362332e+077, 6.25055193e+079,
6.55128557e+081, 6.86648845e+083, 7.19685673e+085, 7.54312006e+087,
7.90604321e+089, 8.28642773e+091, 8.68511374e+093, 9.10298178e+095,
9.54095476e+097, 1.00000000e+100])```
```python
#创建一个数值范围在0到1的随机数
#权重初始化方式
r = np.random.random([3,3])
print(r)
》》》array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19])
"""
numpy.random.rand(d0,d1,…,dn)
rand函数根据给定维度生成[0,1)之间的数据，包含0，不包含1
dn表格每个维度
返回值为指定维度的array
numpy.random.randn(d0,d1,…,dn)
randn函数返回一个或一组样本，具有标准正态分布。
dn表格每个维度
返回值为指定维度的array"""
#随机值是按照标准正态分布创建的
np.random.seed(0)
r = np.random.randn(3,3)
r = np.random.randn(3,3)
# print(help(np.random.rand)) #查看帮助
print(r)
》》》 [[ 0.4105985 0.14404357 1.45427351]
[ 0.76103773 0.12167502 0.44386323]
[ 0.33367433 1.49407907 -0.20515826]]
函数创建数组
1. np.ones_like(a) ：根据数组a的形状生成一个全1数组
2. np.zeros_like(a) ：根据数组a的形状生成一个全0数组
3. np.full_like(a,val) ：根据数组a的形状生成一个数组，每个元素值都是val
4. np.linspace() ：根据起止数据等间距地填充数据，形成数组
5. np.concatenate() ：将两个或多个数组合并成一个新的数组
数组的维度变换
1. .reshape() ：不改变数组元素，返回一个shape形状的数组，原数组不变
2. .resize() ：与.reshape（）功能一致，但修改原数组
3. .swapaxes(ax1,ax2) ：将数组n各维度中两个维度进行调换
4. .flatten() ：对数组进行降维，返回折叠后的一维数组，原数组不变
a = np.ones((2,3,4))
a
》》》array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
a.reshape((3,8)) #不改变原数组，会返回一个新的，而resize会更改原数组
b = a.flatten()
b
ndarray 数组的类型转换
new_a = a.astype(new_type)
astype一定会创建新的数组（原始数组的一个拷贝），即使两个类型一致
a = np.ones((2,3,4),dtype = np.int)
a
b = a.astype(np.float)
b
数组向列表的转换
ls = a.tolist()
a = np.full((2,3,4),25,dtype = np.int32)
a
a.tolist()
对数组的操作
1. 索引：获取数组中特定位置元素的过程
1. 一维数组的索引和切片与python类似
2. 切片：获取数组元素子集的过程
# 一维数组索引
a = np.array([9,8,7,6,5])
a[2]
#一维数组切片
a[ 1 : 4 : 2] #1是起始，4是终止，2是步长
np.random的统计函数
1. sum(a,axis = none) ：根据给定轴axis计算数组a相关元素之和，axis整数或元组
2. mean(a.axis = none) ：根据给定轴axis计算数组a相关元素的期望，axis整数或元组
3. average(a.axis = None,weights = None) ：根据给定轴axis计算数组a相关元素的加权平均值
4. std(a,axis = None) ：根据给定轴axis计算数组a相关元素的标准差
5. var(a.axis = None) ：根据给定轴axis计算数组a相关元素方差
import numpy as np
a = np.arange(15).reshape(3,5)
a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
# sum,对基本元素进行求和运算
np.sum(a)
105
#mean，对数组而言，最外层的维度是0，内层的维度是1，axis = 1，表示的是对数组的第二维度进行平均数计算
np.mean(a,axis = 1) #对同一行各列计算
np.mean(a,axis = 0) #对第一维度，同一列各行计算
array([5., 6., 7., 8., 9.])
#average
np.average(a,axis = 0,weights = [10,5,1]) #4.1875 = 2*10 + 7*5 + 12*1/(10+5+1)
array([2.1875, 3.1875, 4.1875, 5.1875, 6.1875])
#std
np.std(a)
4.320493798938574
#var
np.var(a)
18.666666666666668
np.random的统计函数1
1. min(a)\max(a) ：计算数组a中元素的最小值和最大值
2. argmin(a)\argmax(a) ：计算数组a中元素的最小值和最大值的降一维后下标
3. unravel_index(index,shape) ：根据shape将一维下标index转换成多维下标
4. ptp(a) ：计算数组a中元素的最大值和最小值的差
5. median(a) ：计算数组a中元素的中位数
import numpy as np
a = np.arange(15,0,-1).reshape(3,5)
a
array([[15, 14, 13, 12, 11],
[10, 9, 8, 7, 6],
[ 5, 4, 3, 2, 1]])
#max
np.max(a)
15
#argmax
np.argmax(a) #扁平化下标
0
#unravel_index
np.unravel_index(np.argmax(a),a.shape) #重塑成多为下标
(0, 0)
# ptp
np.ptp(a)
14
# median
np.median(a)
8.0
np.random的梯度函数
1. np.gradient(f) ：计算数组f中的元素的梯度，当f为多维时，返回每个维度梯度
梯度：连续值之间的变化率，即斜率
XY坐标轴连续三个X坐标对应的Y轴值为：a，b，c，其中，b的梯度是：（c-a）/2
斜率是表示一条直线（或曲线的切线）关于（横）坐标轴倾斜程度的量。它通常用直线（或曲线的切线）与（横）坐标轴夹角的正切，或两点的纵坐标之差与横坐标之差的比来表示
import numpy as np
a = np.random.randint(0,20,(5))
a
array([15, 9, 6, 8, 14])
np.gradient(a) #第二个元素的梯度值 = （第三个元素-第一个元素）/2 ##最后一个元素的梯度值 = （自身 -前一个元素）/1
array([-6. , -4.5, -0.5, 4. , 6. ])
b = np.random.randint(0,20,(5))
b
array([ 5, 5, 16, 2, 15])
np.gradient(b)
array([ 0. , 5.5, -1.5, -0.5, 13. ])
a = np.random.randint(0,50,(3,5))
a
array([[19, 25, 29, 35, 10],
[ 6, 49, 21, 21, 29],
[23, 1, 20, 29, 45]])
np.gradient(a)
#会返回两个数组结果，第一个是最外层维度的梯度，其次是第二层维度的梯度
#梯度反映了数据的变化率，在进行图像处理声音处理的时候可以发挥很大的作用
[array([[-13. , 24. , -8. , -14. , 19. ],
[ 2. , -12. , -4.5, -3. , 17.5],
[ 17. , -48. , -1. , 8. , 16. ]]),
array([[ 6. , 5. , 5. , -9.5, -25. ],
[ 43. , 7.5, -14. , 4. , 8. ],
[-22. , -1.5, 14. , 12.5, 16. ]])]
a = np.random.randint(0,50,(3,3,5))
a
array([[[11, 21, 32, 34, 37],
[45, 18, 21, 8, 15],
[19, 18, 4, 9, 3]],
[[18, 14, 2, 47, 27],
[ 9, 38, 4, 7, 22],
[12, 22, 3, 48, 9]],
[[10, 2, 36, 35, 33],
[19, 2, 2, 39, 41],
[ 1, 29, 24, 15, 33]]])
np.gradient(a)
[array([[[ 7. , -7. , -30. , 13. , -10. ],
[-36. , 20. , -17. , -1. , 7. ],
[ -7. , 4. , -1. , 39. , 6. ]],
[[ -0.5, -9.5, 2. , 0.5, -2. ],
[-13. , -8. , -9.5, 15.5, 13. ],
[ -9. , 5.5, 10. , 3. , 15. ]],
[[ -8. , -12. , 34. , -12. , 6. ],
[ 10. , -36. , -2. , 32. , 19. ],
[-11. , 7. , 21. , -33. , 24. ]]]),
array([[[ 34. , -3. , -11. , -26. , -22. ],
[ 4. , -1.5, -14. , -12.5, -17. ],
[-26. , 0. , -17. , 1. , -12. ]],
[[ -9. , 24. , 2. , -40. , -5. ],
[ -3. , 4. , 0.5, 0.5, -9. ],
[ 3. , -16. , -1. , 41. , -13. ]],
[[ 9. , 0. , -34. , 4. , 8. ],
[ -4.5, 13.5, -6. , -10. , 0. ],
[-18. , 27. , 22. , -24. , -8. ]]]),
array([[[ 10. , 10.5, 6.5, 2.5, 3. ],
[-27. , -12. , -5. , -3. , 7. ],
[ -1. , -7.5, -4.5, -0.5, -6. ]],
[[ -4. , -8. , 16.5, 12.5, -20. ],
[ 29. , -2.5, -15.5, 9. , 15. ],
[ 10. , -4.5, 13. , 3. , -39. ]],
[[ -8. , 13. , 16.5, -1.5, -2. ],
[-17. , -8.5, 18.5, 19.5, 2. ],
[ 28. , 11.5, -7. , 4.5, 18. ]]])]
图像的数组表示
1. 由RGB色彩模式，取值范围是0-255
2. 处理图像的库：PIL；python image library
a. import PIL
b. pip install pillow
c. from PIL import Image：一个图像代表一个image的实例
3. 图像是一个由像素组成的二维矩阵，每个像素都是一个RGB值
from PIL import Image as image
import numpy as np
im = np.array(image.open("D:/pick/20170211061910157.jpg"))
print(im.shape,im.dtype)
#图像时一个三维数组，维度分别是高度，宽度和像素RGB值，而在第三维度RGB上有三个元素，分别由uint8类型表示
(660, 990, 3) uint8
# print(im)
图像的变换
1. 读入图像后，获得像素的RGB值，修改后保存为新的文件
from PIL import Image as image
import numpy as np
im = np.array(image.open("D:/pick/20170211061910157.jpg")) #将图像变成数组
print(im.shape,im.dtype)
b = [255,255,255] -im
n_im = image.fromarray(b.astype('uint8')) #将数组b重新生成一个图像
n_im.save("D:/pick/2020-03-31.jpg") #保存
(660, 990, 3) uint8
灰度处理
from PIL import Image as image
import numpy as np
im = np.array(image.open("D:/pick/20170211061910157.jpg").convert("L")) #将图像变成数组.convert("L")是指将图像变成一个灰度图像，生成的数组不再是三维，而是二维的，像素中的值对应的不再是RGB的值，而是灰度值
print(im.shape,im.dtype)
b = 255 -im
n_im = image.fromarray(b.astype('uint8')) #将数组b重新生成一个图像
n_im.save("D:/pick/2020-03-31-1.jpg") #保存
(660, 990) uint8
from PIL import Image as image
import numpy as np
im = np.array(image.open("D:/pick/20170211061910157.jpg").convert("L")) #将图像变成数组.convert("L")是指将图像变成一个灰度图像，生成的数组不再是三维，而是二维的，像素中的值对应的不再是RGB的值，而是灰度值
print(im.shape,im.dtype)
b = (100/255)*im + 150 #区间变换
n_im = image.fromarray(b.astype('uint8')) #将数组b重新生成一个图像
n_im.save("D:/pick/2020-03-31-2.jpg") #保存
(660, 990) uint8
from PIL import Image as image
import numpy as np
im = np.array(image.open("D:/pick/20170211061910157.jpg").convert("L")) #将图像变成数组.convert("L")是指将图像变成一个灰度图像，生成的数组不再是三维，而是二维的，像素中的值对应的不再是RGB的值，而是灰度值
print(im.shape,im.dtype)
b = 255 * (im/255)**2 #像素平方
n_im = image.fromarray(b.astype('uint8')) #将数组b重新生成一个图像
n_im.save("D:/pick/2020-03-31-3.jpg") #保存
(660, 990) uint8
图像的手绘效果
1. 黑白灰色系
2. 边界线条较重
3. 相同或相近色彩趋于白色
4. 略有光源效果
1. 利用像素之间的梯度值和虚拟深度值对图像进行重构，根据灰度变化来模拟人类视觉的明暗晨读
import numpy as np
from PIL import Image as image
a = np.array(image.open("D:/pick/20170211061910157.jpg").convert("L")).astype("float")
depth = 10. #预设虚拟深度为10 ，取值范围时（0-100）
grad = np.gradient(a) #取图像灰度的梯度值，梯度值时表示的灰度的变化率，通过改变梯度值来间接改变图像的明暗程度
grad_x,grad_y = grad #分别取横x纵y图像梯度值
grad_x = grad_x *depth/100
grad_y = grad_y *depth/100 #根据深度调整x和y方向的梯度值，立体效果通过增加虚拟深度值来实现
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) #光源对x轴的影响
dy = np.cos(vec_el)*np.sin(vec_az) #光源对y轴的影响
dz = np.sin(vec_el) #光源对z轴的影响
b = 255 *(dx*uni_x + dy*uni_y +dz*uni_z) #光源归一化
b = b.clip(0,255)
im = image.fromarray(b.astype("uint8")) #重构图像
im.save("D:/pick/2020-03-31-4.jpg")
Matplotlib库的使用
1. matplotlib.pyplot是绘制各类可视化图形的命令子库，相当于快捷方式
2. from matplotlib.pyplot as plt
简单的折线图绘制及保存
# 简单的折线绘制1
import matplotlib.pyplot as plt
plt.plot([3,1,4,2,5]) #只有一行时，会被当作y轴，x轴是索引
plt.ylabel("grade")
plt.savefig("D:/pick/test",dpi = 600) #png文件，dpi是指每英寸里包含点的数量，600相对较高了，png是默认
plt.show()
# 简单的折线绘制2
import matplotlib.pyplot as plt
plt.plot([1,3,5,6,9],[5,8,3,12,21])
plt.xlabel("xaxis")
plt.ylabel("yaxis")
plt.subplot(3,3,4)
plt.show()
设定x轴和y轴的距离间隔
plt.axis([-1,10,0,6]) #表示 x轴起始于 -1到10，y轴起始于1到6
[-1, 10, 0, 6]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QltBwujf-1585829729732)(output_69_1.png)]
多张图表绘制在一起
plt.subplot(nrows,ncols,plot_number)
在全局绘图区域中创建一个子分区体系，并定位到一个子绘图区域
plt.subplot(324)表示三行两列，当前图形在第4个子区域，也就是第二行第二列
import numpy as np
import matplotlib.pyplot as plt
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(2,1,2)
plt.plot(a, np.cos(2*np.pi*a),'r--')
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HRhqkm2w-1585829729732)(output_71_0.png)]
pyplot的plot函数 绘制多条曲线
plt.plot(x,y, format_string, **kwargs)
x: x轴数据，可以是列表或数组，可选
y:y轴数据，可以是列表或数组。
format_string: 控制曲线的格式字符串，可选
**kwargs:第二组或更多(x,y,formatz_string,**kwargs)
多条曲线绘制时，必须给出x
import matplotlib.pyplot as plt
import numpy as np
a = np.arange(10)
plt.plot(a,a*1.5,a,a*2.5,a,a*3.5,a,a*4.5,a,a*5.5,a,a*6.5,a,a*7.5,a,a*8.5,a,a*9.5,a,a*10.5,a,a*13.5,a,a*14.5,a,a*15.5,a,a*16.5,a,a*17.5,a,a*18.5)
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VskHMlFD-1585829729733)(output_73_0.png)]
format_string：控制曲线的的格式字符串，有颜色字符和风格字符以及标记字符组成
颜色字符： 线条： 数据点标记包括字符：.,<>^hH+xDd|sp*以及数字1234
'b' 蓝色 "-" 实线
'g' 绿色 "--" 破折线
'r' 红色 "-." 点划线
'e' 青色 ":" 虚线
'm' 洋红色 "" 无线条
'y' 黄色
'k' 黑色
0.8 灰度值字符串
”#008000“ RGB某颜色\
其他参数：
color：控制颜色，color = "green" 等价于 'g'
linestyle：控制线条 ，linestyle = "dashed"
marker：标记风格，marker = "o"
markerfacecolor ：标记颜色，markerfacecolor = "blue"
markersize：标记尺寸，markersize = 20
import matplotlib.pyplot as plt
import numpy as np
a = np.arange(10)
plt.plot(a,a*1.5,"go-",a,a*2.5,"rH-",a,a*3.5,"b*:",a,a*4.5,"kd",a,a*5.5)
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0jemYswV-1585829729733)(output_75_0.png)]
py.plot默认的不支持中文显示
需要引入matploylib来修改字体
import matplotlib
matplotlib.rcParams["font.family"] = "SimHei" ;该属性是控制字体风格，将其卸载绘图的第一行
"font.family" ：用于显示的字体的名字
"font.style"： 字体风格，正常normal或者斜体italic
"font.size" ：字体大小，整数字号，或者large x-small
#会改变所有的文本配置，不建议使用
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mat
def f(t): #能量衰减曲线
return np.exp(-t) * np.cos(2*np.pi*t)
mat.rcParams["font.family"]='STSong' #此类设置会改变所有的文本配置
mat.rcParams['font.size']=15
a = np.arange(0.0,5.0,0.02)
plt.subplot(211)
plt.xlabel("横轴：时间")
plt.ylabel("纵轴：振幅")
plt.plot(a,f(a))
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0yxkUwWc-1585829729734)(output_77_0.png)]
import numpy as np
import matplotlib.pyplot as plt
def f(t): #能量衰减曲线
return np.exp(-t) * np.cos(2*np.pi*t)
a = np.arange(0.0,5.0,0.02)
plt.xlabel("横轴：时间",fontproperties = "SimHei",fontsize = 15)
plt.ylabel("纵轴：振幅",fontproperties = "SimHei",fontsize = 15)
plt.plot(a,f(a))
[<matplotlib.lines.Line2D at 0x1dfb23fc388>]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qDPJnzmS-1585829729735)(output_78_1.png)]
pyplot的文本显示方法
1. plt.xlabel()：对x轴增加文本标签
2. plt.ylabel()：对y轴增加文本标签
3. plt.title()：对图形整体增加文本标签
4. plt.text() ：在任意位置增加文本
5. plt.annotate(s,xy=arrow_crd,xytext=text_crd,arrowprops=dict) ：图形中增加带箭头的注解
正弦波实例
import numpy as np
import matplotlib.pyplot as plt
#绘图
a = np.arange(0.0,5.0,0.02)
plt.plot(a,np.cos(2*np.pi*a),"g--")
#调参
plt.xlabel("横轴：时间",fontproperties = "SimHei",fontsize = 15)
plt.ylabel("纵轴：振幅",fontproperties = "SimHei",fontsize = 15)
plt.title(r'正弦波实例 $y=cos(2\pi x)$',fontsize = 25,fontproperties = "SimHei")
plt.text(2,1,r'$\mu=100$',fontsize = 16)
plt.axis([-1,6,-2,2])
plt.grid(True)
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5RI3Rrro-1585829729735)(output_81_0.png)]
import numpy as np
import matplotlib.pyplot as plt
#绘图
a = np.arange(0.0,5.0,0.02)
plt.plot(a,np.cos(2*np.pi*a),"g--")
#调参
plt.xlabel("横轴：时间",fontproperties = "SimHei",fontsize = 15)
plt.ylabel("纵轴：振幅",fontproperties = "SimHei",fontsize = 15)
plt.title(r'正弦波实例 $y=cos(2\pi x)$',fontsize = 25,fontproperties = "SimHei")
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()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qWDIIeJA-1585829729736)(output_82_0.png)]
import numpy as np
from PIL import Image as image
a = image.open("D:/pick/20170211061910157.jpg")
a.show()
多图形绘制
1. plt.subplot2grid(GridSpec,CurSpec,colspan=1,rowspan=1)
理念：设定网格；选中网格，确定选中行列区域数量，编号从0开始
plt.subplot2grid((3,3),(1,0),colspan=2)
表示：总共为三行三列，其中选中在第二行和第一列开始，长度为3
但是每次都要对图形进行约束
2. GridSpec类
import matplotlib.gridspec as gridspec
gs = gridspec.GridSpec(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]) #表示第三行和第二列的区域为一个图形区域
理解数据对应的含义以及展示这种含义的图形方法是很关键的。
基础图形绘制
#饼图
import matplotlib.pyplot as plt
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 = False,startangle=90)
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fy2Ft4vk-1585829729736)(output_87_0.png)]
#饼图
import matplotlib.pyplot as plt
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 = False,startangle=90)
plt.axis("equal")
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dys8dIUg-1585829729737)(output_88_0.png)]
#直方图
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
mu, sigma = 100,20 #均值和方差
a = np.random.normal(mu,sigma,size=100)
plt.hist(a,20,normed=0,histtype="stepfilled",facecolor = 'b',alpha = 0.75) #第二个参数（bin）是指直方图的个数；noemed=1是指将元素出现的频率，为0是指出现的个数
plt.title("Histogram")
plt.show()
C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:8: MatplotlibDeprecationWarning:
The 'normed' kwarg was deprecated in Matplotlib 2.1 and will be removed in 3.1. Use 'density' instead.
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-grDBv66y-1585829729737)(output_89_1.png)]
#直方图
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
mu, sigma = 100,20
a = np.random.normal(mu,sigma,size=100)
plt.hist(a,40,normed=1,histtype="stepfilled",facecolor = 'b',alpha = 0.75)
plt.title("Histogram")
plt.show()
C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:8: MatplotlibDeprecationWarning:
The 'normed' kwarg was deprecated in Matplotlib 2.1 and will be removed in 3.1. Use 'density' instead.
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8HgDpmXm-1585829729738)(output_90_1.png)]
#直方图
import numpy as np
import matplotlib.pyplot as plt
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)
plt.title("Histogram")
plt.show()
C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:8: MatplotlibDeprecationWarning:
The 'normed' kwarg was deprecated in Matplotlib 2.1 and will be removed in 3.1. Use 'density' instead.
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fTN9YP0L-1585829729738)(output_91_1.png)]
面向对象绘制极坐标
import numpy as np
import matplotlib.pyplot as plt
N = 20 #绘制坐标中数据的个数
theta = np.linspace(0.0,2*np.pi,N , endpoint = False)#从0到2pi也就是360°，分成20个不同的角度
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 i ,bar in zip(radii,bars):
bar.set_facecolor(plt.cm.viridis(i /10.))
bar.set_alpha(0.5)
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xZ1m446F-1585829729739)(output_93_0.png)]
散点图绘制
import numpy as np
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot(10 * np.random.rand(100),10 * np.random.randn(100),'o')
ax.set_title("Simple Scatter")
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CiVDqc26-1585829729739)(output_95_0.png)]
import numpy as np
import matplotlib.pyplot as plt
N = 20 #绘制坐标中数据的个数
theta = np.linspace(0.0,2*np.pi,N , endpoint = False)#从0到2pi也就是360°，分成20个不同的角度
radii = np.random.rand(N)
radii
array([0.80619399, 0.70388858, 0.10022689, 0.91948261, 0.7142413 ,
0.99884701, 0.1494483 , 0.86812606, 0.16249293, 0.61555956,
0.12381998, 0.84800823, 0.80731896, 0.56910074, 0.4071833 ,
0.069167 , 0.69742877, 0.45354268, 0.7220556 , 0.86638233])
第三周导学 pandas，便于操作数据的数据类型及分析函数，基于numpy实现
series 相当于一维，由一组数据和相关的数据索引组成
dataframe 相当于二维到多维
import pandas as pd
a = pd.Series(range(20))
a #索引，数值
a.cumsum() #计算前N项之和
0 0
1 1
2 3
3 6
4 10
5 15
6 21
7 28
8 36
9 45
10 55
11 66
12 78
13 91
14 105
15 120
16 136
17 153
18 171
19 190
dtype: int64
a = pd.Series([1,2,3,4],index = ['a','b','c','d'])
#等价于 a = pd.Series([1,2,3,4], ['a','b','c','d'])
a
# a = pd.Series([[1,2,3,4],[2,3,4,5]],index = ['a','b'])
a
a 1
b 2
c 3
d 4
dtype: int64
生成和创建Series类型
从标量值创建：pd.Series(标量,index=["索引不能省略"]）
从字典创建：pd.Series({key:value,key:value})# key会变成索引
pd.Series({key:value,key:value}，index=[])#若再提供索引，则会从字典中选取对应的值，若index存在没有的数据，则默认为NaN
从ndarray类型创建：pd.Series(np.arange(5)) 生成从0-4的数值也可以给定索引 index =np.arange(9,4,-1)
从列表
Series的基本操作
a.index ：获取所有index
a.values：获取所有value
a['key'] ：自定义索引获取值 #两种都可以用，但是不能混用
a[1] ：获取值
Series类型本身是索引加数值的类型，那么对它进行的索引和切片生成的也都是Series类型，若只选中一个值，则返回的是值而不是Series类型
a.index
a.values
a['a'] #输出key为a的value
a[2] #输出第三个
a[:3] #输出前三个
a[a > a.median()] #输出大于中位数的
import numpy as np
np.exp(a) #进行e的x次方运算
'c' in a #判断c是否在a的自定义索引中，不会判断自动索引
a.get('g',200) #a里不含有g，理论上应该返回NaN，但是因为有第二个参数，索引会返回后面的值
a
a 1
b 2
c 3
d 4
dtype: int64
Series的对齐操作
基于索引的运算
Series + Series ：会取两个Series的并集，（自定义）索引相同的进行相加，不同的返回NaN
a = pd.Series([1,2,3,4],index = ['a','b','c','d'])
b = pd.Series([10,20,30,40,50],index = ['w','b','d','v','f'])
a + b
a NaN
b 22.0
c NaN
d 34.0
f NaN
v NaN
w NaN
dtype: float64
Series的name属性
Series对象和索引都可以有一个名字，存储在属性.name中
b = pd.Series([10,20,30,40,50],index = ['w','b','d','v','f'])
b.name
b.name = "Series对象"
b.index.name = "索引列"
b
b.name
'Series对象'
Series的修改
随时修改，即时生效
b = pd.Series([10,20,30,40,50],index = ['w','b','d','v','f'])
b['b'] = 22
b.name
b.name = "Series对象"
b.name
b.name = "Series对象1"
b
b['w','b'] = 111
b
w 111
b 111
d 30
v 40
f 50
Name: Series对象1, dtype: int64
dataframe的数据类型
是由共用相同索引的一组列组成的多列数据
纵向操作axis = 0，横向操作axis = 1
创建方式
二维的ndarray对象
一维的adarray和列表和字典和元组和Series构成的字典
Series类型
其他dataframe类型
#从二维ndarray创建
import numpy as np
import pandas as pd
a = pd.DataFrame(np.arange(10).reshape(5,2))
a #就是原始的数据增加了横向和纵向的索引
| 0 | 1 | |
|---|---|---|
| 0 | 0 | 1 |
| 1 | 2 | 3 |
| 2 | 4 | 5 |
| 3 | 6 | 7 |
| 4 | 8 | 9 |
#从一维ndarray对象字典创建
import pandas as pd
dt = {"one":pd.Series([1,2,3],index = ['a','b','c']),
"two":pd.Series([4,5,6,7],index = ['a','b','c','d'])} #先是创建两个Series分别为1列的，然后存储在字典里，在利用dataframe是就会将字典的key当作列名进行变换
a = pd.DataFrame(dt)
a
pd.DataFrame(dt,index = ['b','c','d'],columns = ['two','three']) #对要制作的DataFrame进行数据选择，分别是纵向选择三行，横向选择两列，若字典中不包含列索引，则为空
| one | two | |
|---|---|---|
| a | 1.0 | 4 |
| b | 2.0 | 5 |
| c | 3.0 | 6 |
| d | NaN | 7 |
#从列表创建
import pandas as pd
a = {'one':[1,2,3,4],"two":[9,8,7,6]}
b = pd.DataFrame(a,index = ['a','b','c','d'])
b
| one | two | |
|---|---|---|
| a | 1 | 9 |
| b | 2 | 8 |
| c | 3 | 7 |
| d | 4 | 6 |
b['one'] #索引列
a 1
b 2
c 3
d 4
Name: one, dtype: int64
b.loc['a'] #索引行
one 1
two 9
Name: a, dtype: int64
b['one']['a']
1
b["one"]['a']
1
pandas的数据操作
.reindex() 能够改变或重排Series和DataFrame索引
import pandas as pd
a = {'one':[1,2,3,4],"two":[9,8,7,6]}
b = pd.DataFrame(a,index = ['a','b','c','d'])
b
| one | two | |
|---|---|---|
| a | 1 | 9 |
| b | 2 | 8 |
| c | 3 | 7 |
| d | 4 | 6 |
b = b.reindex(index = ['aa','bb','cc','dd'])
b
| one | two | |
|---|---|---|
| aa | NaN | NaN |
| bb | NaN | NaN |
| cc | NaN | NaN |
| dd | NaN | NaN |
b = b.reindex(columns = ["two",'one'])
b
| two | one | |
|---|---|---|
| a | 9 | 1 |
| b | 8 | 2 |
| c | 7 | 3 |
| d | 6 | 4 |
import pandas as pd
a = {'one':[1,2,3,4],"two":[9,8,7,6]}
b = pd.DataFrame(a,index = ['a','b','c','d'])
c = b.columns.insert(2,'three') ##新增列
c
Index(['one', 'two', 'three'], dtype='object')
import pandas as pd
a = {'one':[1,2,3,4],"two":[9,8,7,6]}
b = pd.DataFrame(a,index = ['a','b','c','d'])
d = b.reindex(columns = c,fill_value = 100) ##新增列添加数值
d
| one | two | three | |
|---|---|---|---|
| a | 1 | 9 | 100 |
| b | 2 | 8 | 100 |
| c | 3 | 7 | 100 |
| d | 4 | 6 | 100 |
##获取行0和列1索引
import pandas as pd
a = {'one':[1,2,3,4],"two":[9,8,7,6]}
b = pd.DataFrame(a,index = ['a','b','c','d'])
b.index
b.columns
Index(['one', 'two'], dtype='object')
索引类型的常用方法
.append(idx) ：链接另一个index对象，产生新的index对象
.diff(idx) ：计算差集，产生新的index对象
.intersection(idx) ：计算交集
.union(idx) ：计算并集
.delete(loc) ：删除loc位置处的元素
.insert(loc,e) ：在loc位置添加一个元素
.drop(index,axis = 0/1) #删除指定的行或列索引和对应的数据,default：axis=0
## pandas的数据类型运算
import numpy as np
import pandas as pd
a = pd.DataFrame(np.arange(12).reshape(3,4))
a
| 0 | 1 | 2 | 3 | |
|---|---|---|---|---|
| 0 | 0 | 1 | 2 | 3 |
| 1 | 4 | 5 | 6 | 7 |
| 2 | 8 | 9 | 10 | 11 |
b = pd.DataFrame(np.arange(20).reshape(4,5))
b
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0 | 1 | 2 | 3 | 4 |
| 1 | 5 | 6 | 7 | 8 | 9 |
| 2 | 10 | 11 | 12 | 13 | 14 |
| 3 | 15 | 16 | 17 | 18 | 19 |
a + b #自动补齐，缺项为NaN
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0.0 | 2.0 | 4.0 | 6.0 | NaN |
| 1 | 9.0 | 11.0 | 13.0 | 15.0 | NaN |
| 2 | 18.0 | 20.0 | 22.0 | 24.0 | NaN |
| 3 | NaN | NaN | NaN | NaN | NaN |
a * b
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0.0 | 1.0 | 4.0 | 9.0 | NaN |
| 1 | 20.0 | 30.0 | 42.0 | 56.0 | NaN |
| 2 | 80.0 | 99.0 | 120.0 | 143.0 | NaN |
| 3 | NaN | NaN | NaN | NaN | NaN |
b.add(a,fill_value = 100)
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0.0 | 2.0 | 4.0 | 6.0 | 104.0 |
| 1 | 9.0 | 11.0 | 13.0 | 15.0 | 109.0 |
| 2 | 18.0 | 20.0 | 22.0 | 24.0 | 114.0 |
| 3 | 115.0 | 116.0 | 117.0 | 118.0 | 119.0 |
b.mul(a,fill_value = 0)
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0.0 | 1.0 | 4.0 | 9.0 | 0.0 |
| 1 | 20.0 | 30.0 | 42.0 | 56.0 | 0.0 |
| 2 | 80.0 | 99.0 | 120.0 | 143.0 | 0.0 |
| 3 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
不同维度间为广播运算，一维Series默认在轴1参与运算
比较运算只能比较同索引的元素，不进行补齐
二维和一维，一维和零维之间为广播运算
采用> < >= <= == != 进行的二元运算产生布尔对象
import numpy as np
import pandas as pd
a = pd.Series(np.arange(6))
b = pd.DataFrame(np.arange(20).reshape(4,5))
a + b # 将一维的行作用于二维的列，缺项为NaN
| 0 | 1 | 2 | 3 | 4 | 5 | |
|---|---|---|---|---|---|---|
| 0 | 0 | 2 | 4 | 6 | 8 | NaN |
| 1 | 5 | 7 | 9 | 11 | 13 | NaN |
| 2 | 10 | 12 | 14 | 16 | 18 | NaN |
| 3 | 15 | 17 | 19 | 21 | 23 | NaN |
b.add(a,axis = 0) #设置运算作用于行
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | 0.0 | 1.0 | 2.0 | 3.0 | 4.0 |
| 1 | 6.0 | 7.0 | 8.0 | 9.0 | 10.0 |
| 2 | 12.0 | 13.0 | 14.0 | 15.0 | 16.0 |
| 3 | 18.0 | 19.0 | 20.0 | 21.0 | 22.0 |
| 4 | NaN | NaN | NaN | NaN | NaN |
| 5 | NaN | NaN | NaN | NaN | NaN |
a >0
0 False
1 True
2 True
3 True
4 True
5 True
dtype: bool
a <b
| 0 | 1 | 2 | 3 | 4 | 5 | |
|---|---|---|---|---|---|---|
| 0 | False | False | False | False | False | False |
| 1 | True | True | True | True | True | False |
| 2 | True | True | True | True | True | False |
| 3 | True | True | True | True | True | False |
数据的排序
空值排序放在末尾
.sort_index()
.sort_value()
b.sort_values(2,ascending = False)
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 3 | 15 | 16 | 17 | 18 | 19 |
| 2 | 10 | 11 | 12 | 13 | 14 |
| 1 | 5 | 6 | 7 | 8 | 9 |
| 0 | 0 | 1 | 2 | 3 | 4 |
数据的基本统计分析
.sum()
.count()
.mean() .median()
.var() .std()
.min() .max()
.argmin() .argmax() 适用于Series计算最大值和最小值所在位置的索引位置，自动索引
.idxmin() .idmax() 适用于Series计算最大值和最小值所在位置的索引位置，自定义索引
.descreibe() ：对数据进行所有统计信息汇总，二维的数据根据0轴进行运算
.descreibe()['count]
相关分析函数
.cov() ：协方差矩阵
.corr() ：计算相关系数矩阵，Person、Spearman、Kendall等系数
可以不用了解公式是如何计算的，如何调用即可
