├── 01第1章 Python语言快速入门 ├── FunctionSet.py ├── Pex1_1.py ├── Pex1_10.py ├── Pex1_11_1.py ├── Pex1_11_2.py ├── Pex1_12.py ├── Pex1_2.py ├── Pex1_3.py ├── Pex1_4.py ├── Pex1_5_1.py ├── Pex1_5_2.py ├── Pex1_5_3.py ├── Pex1_6.py ├── Pex1_7.py ├── Pex1_8.py ├── Pex1_9.py ├── Pz1_1.py ├── Pz1_10.py ├── Pz1_11.py ├── Pz1_12.py ├── Pz1_13.py ├── Pz1_14.py ├── Pz1_15.py ├── Pz1_16.py ├── Pz1_17.py ├── Pz1_18.py ├── Pz1_19.py ├── Pz1_2.py ├── Pz1_20.py ├── Pz1_21.py ├── Pz1_22.py ├── Pz1_3.py ├── Pz1_4.py ├── Pz1_5.py ├── Pz1_6.py ├── Pz1_7.py ├── Pz1_8.py ├── Pz1_9.py └── __pycache__ │ └── FunctionSet.cpython-37.pyc ├── 02第2章 数据处理与可视化 ├── Pdata2_12.txt ├── Pdata2_18_1.txt ├── Pdata2_18_2.txt ├── Pdata2_19.txt ├── Pdata2_20.txt ├── Pdata2_21.txt ├── Pdata2_22.bin ├── Pdata2_23_1.npy ├── Pdata2_23_2.npz ├── Pdata2_25.txt ├── Pdata2_26.txt ├── Pdata2_32.txt ├── Pdata2_33.xlsx ├── Pdata2_34.xlsx ├── Pdata2_42.txt ├── Pex2_1.py ├── Pex2_10.py ├── Pex2_11.py ├── Pex2_12.py ├── Pex2_13.py ├── Pex2_14.py ├── Pex2_15.py ├── Pex2_16.py ├── Pex2_17.py ├── Pex2_18.py ├── Pex2_19.py ├── Pex2_2.py ├── Pex2_20.py ├── Pex2_21.py ├── Pex2_22.py ├── Pex2_23.py ├── Pex2_24.py ├── Pex2_25.py ├── Pex2_26.py ├── Pex2_27.py ├── Pex2_28.py ├── Pex2_29.py ├── Pex2_3.py ├── Pex2_30.py ├── Pex2_31.py ├── Pex2_32.py ├── Pex2_33.py ├── Pex2_34.py ├── Pex2_35.py ├── Pex2_36.py ├── Pex2_37.py ├── Pex2_38.py ├── Pex2_39.py ├── Pex2_4.py ├── Pex2_40.py ├── Pex2_41.py ├── Pex2_42_1.py ├── Pex2_42_2.py ├── Pex2_43.py ├── Pex2_44.py ├── Pex2_45.py ├── Pex2_45_1.py ├── Pex2_45_2.py ├── Pex2_46.py ├── Pex2_47.py ├── Pex2_48_1.py ├── Pex2_48_2.py ├── Pex2_5.py ├── Pex2_6.py ├── Pex2_7.py ├── Pex2_8.py ├── Pex2_9.py ├── Trade.xlsx ├── figure2_23.png ├── figure2_36.png ├── figure2_38.png ├── figure2_39.png ├── figure2_40.png ├── figure2_41.png ├── figure2_42_1.png ├── figure2_42_2.png ├── figure2_43.png ├── figure2_44.png ├── figure2_45.png ├── figure2_46.png ├── figure2_47.png ├── figure2_48.png └── 附件1：区域高程数据.xlsx ├── 03第3章 Python在高等数学和工程数学的应用 ├── Pex3_1.py ├── Pex3_10.py ├── Pex3_11.py ├── Pex3_12.py ├── Pex3_13.py ├── Pex3_14.py ├── Pex3_15.py ├── Pex3_16.py ├── Pex3_17.py ├── Pex3_18.py ├── Pex3_19.py ├── Pex3_2.py ├── Pex3_20.py ├── Pex3_21.py ├── Pex3_22_1.py ├── Pex3_22_2.py ├── Pex3_23.py ├── Pex3_24.py ├── Pex3_25.py ├── Pex3_26.py ├── Pex3_27.py ├── Pex3_28.py ├── Pex3_29.py ├── Pex3_3.py ├── Pex3_30.py ├── Pex3_31.py ├── Pex3_32.py ├── Pex3_33.py ├── Pex3_34.py ├── Pex3_35.py ├── Pex3_36.py ├── Pex3_37.py ├── Pex3_38.py ├── Pex3_39.py ├── Pex3_4.py ├── Pex3_40.py ├── Pex3_41.py ├── Pex3_42.py ├── Pex3_5_1.py ├── Pex3_5_2.py ├── Pex3_6.py ├── Pex3_7.py ├── Pex3_8.py ├── Pex3_9.py ├── figure3_16.png ├── figure3_17.png ├── figure3_29.png ├── figure3_32.png ├── figure3_41.png └── figure3_42.png ├── 04第4章 概率论与数理统计 ├── Pdata2_33.xlsx ├── Pdata4_20.txt ├── Pdata4_23.xlsx ├── Pdata4_26_1.xlsx ├── Pdata4_26_2.xlsx ├── Pdata4_29.xlsx ├── Pdata4_6_1.xlsx ├── Pdata4_6_2.txt ├── Pdata4_9.txt ├── Pex4_1.py ├── Pex4_10.py ├── Pex4_11.py ├── Pex4_12.py ├── Pex4_13.py ├── Pex4_14_1.py ├── Pex4_14_2.py ├── Pex4_14_3.py ├── Pex4_15.py ├── Pex4_16.py ├── Pex4_17.py ├── Pex4_18.py ├── Pex4_19.py ├── Pex4_2.py ├── Pex4_20.py ├── Pex4_21.py ├── Pex4_22.py ├── Pex4_23.py ├── Pex4_24.py ├── Pex4_25_1.py ├── Pex4_25_2.py ├── Pex4_25_3.py ├── Pex4_26.py ├── Pex4_27.py ├── Pex4_28.py ├── Pex4_29.py ├── Pex4_3.py ├── Pex4_30.py ├── Pex4_31.py ├── Pex4_4.py ├── Pex4_5.py ├── Pex4_6.py ├── Pex4_7.py ├── Pex4_8.py ├── Pex4_9.py ├── figure4-9.png ├── figure4_10.png ├── figure4_11.png ├── figure4_12.png ├── figure4_2.png ├── figure4_22.png ├── figure4_25.png ├── figure4_27.png ├── figure4_8.png ├── figure4_9.png └── sunspots.csv ├── 05第5章 线性规划 ├── Pan5_1_1.py ├── Pan5_1_2.py ├── Pan5_1_3.py ├── Pdata5_6.xlsx ├── Pex5_1.py ├── Pex5_2_1.py ├── Pex5_2_2.py ├── Pex5_3.py ├── Pex5_4.py ├── Pex5_5.py ├── Pex5_6.py ├── Pex5_7.py ├── Pex5_7_2.py ├── figure5_1_1.png └── figure5_1_2.png ├── 06第6章 整数规划与非线性规划 ├── Pan6_1.xlsx ├── Pan6_1_1.py ├── Pan6_1_2.py ├── Pex6_1.py ├── Pex6_2.py ├── Pex6_3_1.py ├── Pex6_3_2.py ├── Pex6_4.py ├── Pex6_5.py ├── Pex6_6.py └── Pex6_7.py ├── 07第7章 插值与拟合 ├── Pdata7_5.txt ├── Pex7_10.py ├── Pex7_4.py ├── Pex7_5.py ├── Pex7_6.py ├── Pex7_7.py ├── Pex7_8.py ├── Pex7_9.py ├── Pfun7_1.py ├── Pfun7_2.py ├── Pfun7_3.py ├── figure7_10.png ├── figure7_4.png ├── figure7_5.png ├── figure7_6.png ├── figure7_7.png ├── laglangri.py └── newton.py ├── 08第8章 微分方程模型 ├── Pan8_1.py ├── Pdata8_10_1.txt ├── Pdata8_10_2.txt ├── Pex8_1.py ├── Pex8_10_1.py ├── Pex8_10_2.py ├── Pex8_11.py ├── Pex8_12.py ├── Pex8_2.py ├── Pex8_3_1.py ├── Pex8_3_2.py ├── Pex8_4.py ├── Pex8_5.py ├── Pex8_6.py ├── Pex8_7.py ├── Pex8_8.py ├── Pex8_9.py ├── figure8_5.png └── figure8_6.png ├── 09第9章 综合评价方法 ├── Pan9_1.py ├── Pdata9_1_1.txt ├── Pdata9_1_2.txt ├── Pdata9_1_3.txt ├── Pdata9_1_4.txt ├── Pdata9_1_5.xlsx ├── Pex9_1.py └── Pex9_2.py ├── 10第10章 图论模型 ├── Pdata10_14.xlsx ├── Pdata10_2.txt ├── Pdata10_3.txt ├── Pdata10_6.txt ├── Pdata10_8.txt ├── Pex10_10.py ├── Pex10_13.py ├── Pex10_14.py ├── Pex10_15.py ├── Pex10_16.py ├── Pex10_17.py ├── Pex10_18.py ├── Pex10_19.py ├── Pex10_2_1.py ├── Pex10_2_2.py ├── Pex10_3.py ├── Pex10_4.py ├── Pex10_5.py ├── Pex10_5.xlsx ├── Pex10_6.py ├── Pex10_7.py ├── Pex10_8.py ├── Pex10_9.py ├── figure10_12.png ├── figure10_14.png ├── figure10_18_1.png ├── figure10_18_2.png ├── figure10_2.png ├── figure10_3.png ├── figure10_7.png ├── figure10_9.png ├── mydijkstra.py ├── mydijkstra1.py ├── mydijkstra2.py ├── mydijkstra3.py ├── mydijkstra4.py ├── mydijkstra5.py ├── mydijkstra6.py └── myfloyd.py ├── 11第11章 多元分析 ├── Pan11_1.py ├── Pan11_1_1.xlsx ├── Pan11_1_2.xlsx ├── Pan11_2.py ├── Pdata11_11.txt ├── Pdata11_2.xlsx ├── Pdata11_7.txt ├── Pdata11_8.txt ├── Pex11_1.py ├── Pex11_10.py ├── Pex11_11.py ├── Pex11_12.py ├── Pex11_13.py ├── Pex11_14.py ├── Pex11_2.py ├── Pex11_3.py ├── Pex11_4.py ├── Pex11_5.py ├── Pex11_6.py ├── Pex11_7.py ├── Pex11_8.py ├── Pex11_9.py ├── Pz11_1.py ├── Pz11_2.py ├── Pz11_3.py ├── Pzdata11_1.npy ├── figure11_11.png ├── figure11_12.png ├── figureZ_3.png ├── figureZ_4.png ├── figure_an1_1.png └── iris.csv ├── 12第12章 回归分析 ├── Pdata12_1.txt ├── Pdata12_3.txt ├── Pdata12_6.txt ├── Pdata12_7_1.txt ├── Pdata12_7_2.txt ├── Pdata12_9.txt ├── Pex12_1.py ├── Pex12_10.py ├── Pex12_2_1.py ├── Pex12_2_2.py ├── Pex12_3.py ├── Pex12_4.py ├── Pex12_5.py ├── Pex12_6.py ├── Pex12_7.py ├── Pex12_8.py ├── Pex12_9.py ├── figure12_1.png ├── figure12_2.png └── gtable11_3.xlsx ├── 13第13章 差分方程模型 ├── Pdata13_6.txt ├── Pex13_1.py ├── Pex13_2.py ├── Pex13_3.py ├── Pex13_4.py ├── Pex13_5.py ├── Pex13_5_1.py ├── Pex13_5_2.py ├── Pex13_5_3.py ├── Pex13_6.py ├── Pex13_7_1.py ├── Pex13_7_2.py ├── Pz13_1.py ├── figure13_1.png ├── figure13_2.png ├── figure13_3.png ├── figure13_4.png └── figure13_5.png ├── 14第14章 模糊数学 ├── Pdata14_12.txt ├── Pex14_10.py ├── Pex14_11.py ├── Pex14_12.py ├── Pex14_6.py ├── Pex14_7.py └── Pex14_9.py ├── 15第15章 灰色系统预测 ├── Pdata15_3.txt ├── Pex15_1.py ├── Pex15_2.py ├── Pex15_3.py ├── Pex15_4_1.py ├── Pex15_4_2.py ├── figure15_1.png └── figure15_2.png ├── 16第16章 Monte Carlo模拟 ├── Pex16_1.py ├── Pex16_10.py ├── Pex16_11.py ├── Pex16_2.py ├── Pex16_4.py ├── Pex16_5.py ├── Pex16_6.py ├── Pex16_7.py ├── Pex16_8.py ├── Pex16_9_1.py ├── Pex16_9_2.py ├── figure16_2.png └── figure16_3.png ├── 17第17章 智能算法 ├── Pdata17_1.txt ├── Pdata17_2.txt ├── Pdata17_3.txt ├── Pdata17_5.txt ├── Pex17_1.py ├── Pex17_2.py ├── Pex17_3.py ├── Pex17_4.py ├── Pex17_5.py ├── figure17_1.png ├── figure17_2.png ├── figure17_2_2.png ├── figure17_2_2_3.png ├── figure17_2_2_4.png ├── figure17_5.png └── game.py ├── 18第18章 时间序列分析 ├── AirPassengers.csv ├── Pdata18_2.xlsx ├── Pdata18_3.txt ├── Pdata18_3.xlsx ├── Pdata18_4.txt ├── Pex18_1_1.py ├── Pex18_1_2.py ├── Pex18_2.py ├── Pex18_3.py ├── Pex18_4.py ├── Pex18_5_1.py ├── Pex18_5_2.py ├── Pex18_6.py ├── austa.csv ├── fadian.txt ├── figure18_1.png ├── figure18_2.png ├── figure18_3.png ├── figure18_4.png ├── figure18_4_2.png ├── figure18_4_3.png ├── figure18_5.png ├── figure18_6.png ├── figure18_7.png ├── sunspots.csv └── train.csv ├── 19第19章 支持向量机 ├── Pex19_1_1.py ├── Pex19_1_2.py ├── Pex19_2.py └── figure19_1.png ├── 20第20章 数字图像处理 ├── Lena.bmp ├── Lena.jpg ├── Pex20_1.py ├── Pex20_10.py ├── Pex20_11.py ├── Pex20_12.py ├── Pex20_13.py ├── Pex20_14.py ├── Pex20_15.py ├── Pex20_16.py ├── Pex20_17.py ├── Pex20_18.py ├── Pex20_19.py ├── Pex20_2.py ├── Pex20_20.py ├── Pex20_3.py ├── Pex20_4.py ├── Pex20_5.py ├── Pex20_6.py ├── Pex20_7.py ├── Pex20_8.py ├── Pex20_9.py ├── Pz20_1.py ├── empire.jpg ├── empire2.jpg ├── figure20_12.png ├── figure20_13.png ├── figure20_15.png ├── figure20_16.png ├── figure20_17.png ├── figure20_19.png ├── figure20_2.png ├── figure20_7.jpg ├── flower.jpg ├── flower2.png ├── logo.jpg ├── peppers.png ├── simsunb.ttf ├── test.avi ├── 玉龙雪山.jpg └── 附件1 │ ├── 000.bmp │ ├── 001.bmp │ ├── 002.bmp │ ├── 003.bmp │ ├── 004.bmp │ ├── 005.bmp │ ├── 006.bmp │ ├── 007.bmp │ ├── 008.bmp │ ├── 009.bmp │ ├── 010.bmp │ ├── 011.bmp │ ├── 012.bmp │ ├── 013.bmp │ ├── 014.bmp │ ├── 015.bmp │ ├── 016.bmp │ ├── 017.bmp │ └── 018.bmp └── 说明.txt /01第1章 Python语言快速入门/FunctionSet.py: -------------------------------------------------------------------------------- 1 | #程序文件FunctionSet.py 2 | def f(x): return x**2+x+1 3 | def g(x): return x**3+2*x+1 4 | def h(x): return 1/f(x) 5 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_1.py 2 | pi=3.14159 3 | r=float(input("请输入圆的半径：")) 4 | print('圆的周长是：',2*pi*r) 5 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_10.py 2 | from math import log, exp, sin, pi 3 | f=lambda n:(1+log(n)+sin(n))/(2*pi) 4 | y=exp(2) 5 | for n in range(1,101): y += f(n) 6 | print("y=%7.4f"%y) 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_11_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_11_1.py 2 | import FunctionSet as fs 3 | print(fs.f(1),'\t',fs.g(2),'\t',fs.h(3)) 4 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_11_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_11_2.py 2 | from FunctionSet import f, g, h 3 | print(f(1),'\t',g(2),'\t',h(3)) 4 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_12.py: -------------------------------------------------------------------------------- 1 | i = 1 2 | sum = 0 3 | while i <= 1000: 4 | sum = sum+i 5 | i = i+1 6 | print("sum=", sum) 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_2.py 2 | a, b = eval(input("请输入a,b两个数：")) #把字符串转化为数值 3 | if a>=b: print("最大数为：",a) 4 | else: print("最大数为：",b) 5 | 6 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_3.py 2 | sum=0; number=int(input("请输入整数：")) 3 | print("从小到大排列输出数字：") 4 | for i in range(1,number+1): 5 | sum += i #设置sum为i的和 6 | print("%d"%(i),end='') 7 | if i1: print("+",end='') #设置输出连加的算式 16 | else: print("=",end='') 17 | print("%d"%(sum)) 18 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_4.py 2 | from math import * #加载数学模块math的所有对象 3 | n=0; x1=float(input("请输入角度：")) 4 | x=radians(x1) 5 | s=a=x 6 | while abs(a)>=1e-6: 7 | a *= -x*x/(2*n+3)/(2*n+2) 8 | n +=1; s += a 9 | print("x={},sin(x)={}".format(x1,s)) 10 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_5_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_5_1.py 2 | def factorial(n): 3 | r = 1 4 | while n > 1: r *= n; n -= 1 5 | return r 6 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_5_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_5_2.py 2 | from Pex1_5_1 import * 3 | print(factorial(5)) 4 | 5 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_5_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_5_3.py 2 | def factorial(n): 3 | r = 1 4 | while n > 1: r *= n; n -= 1 5 | return r 6 | print(factorial(5)) #调用函数 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_6.py 2 | f=lambda a,b=2,c=5: a-b+c #使用默认值参数 3 | print("f=",f(10,20)) #输出: f=-5 4 | print("f=",f(10,20,30)) #输出：f=20 5 | print("f=",f(c=20,a=10,b=30)) #使用关键字实参，输出：f=0 6 | 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_7.py 2 | f=lambda n,m:sum([k**m for k in range(1,n+1)]) 3 | s=f(100,1)+f(50,2)+f(10,-1) 4 | print("s=%10.4f"%(s)) 5 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_8.py 2 | n=int(input("请输入n的值：")) 3 | def fac(n): 4 | if n<=1: return 1 5 | else: return n*fac(n-1) 6 | m=fac(n) #调用函数 7 | print("%d!=%5d"%(n,m)) 8 | 9 | 10 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pex1_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex1_9.py 2 | x,n=eval(input("请输入x和n的值：")) 3 | def p(x,n): 4 | if n==1: return x 5 | else: return x*(1-p(x,n-1)) 6 | v=p(x,n) #调用函数 7 | print("p(%d,%d)=%d"%(x,n,v)) 8 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_1.py 2 | print("Hello, World!!!") 3 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_10.py 2 | a=[1,2,3]; a.append(4) #在列表末尾添加数字4 3 | print(a) #显示：[1, 2, 3, 4] 4 | a.extend([3,2,1]) #在列表末尾添加3个元素 5 | print(a) #显示：[1, 2, 3, 4, 3, 2, 1] 6 | a.insert(0,-1) #把-1插到第一个元素的位置 7 | print(a) #显示： 8 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_11.py 2 | a=[10, 20, 30, 5, 8, 5, 8, 6, 6]; 3 | a.pop() #删除最后一个元素 4 | print(a) #显示：[10, 20, 30, 5, 8, 5, 8, 6] 5 | a.pop(2) #删除第3个元素 6 | print(a) #显示：[10, 20, 5, 8, 5, 8, 6] 7 | a.remove(8); a.remove(8) #依次从左往右删除两个8 8 | print(a) #显示：[10, 20, 5, 5, 6] 9 | a.clear() #清空列表 10 | print(a) #显示：[] 11 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_12.py 2 | d={'姓名':'张三','年龄':33,'子女':{'子':'张四','女':'张玲'}} #构造字典 3 | print(d) #显示：{'姓名': '张三', '年龄': 33, '子女': {'子': '张四', '女': '张玲'}} 4 | print(d['年龄']) #显示年龄的值，输出：33 5 | d['年龄']=35 #将字典中'年龄'键的值修改为35 6 | print(d) #显示修改后字典，输出：{'姓名': '张三', '年龄': 35, '子女': {'子': '张四', '女': '张玲'}} 7 | d['户籍']='烟台' 8 | print(d) 9 | d.pop('子女') 10 | print(d) 11 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_13.py 2 | a=set('abcde') #把字符串转化为集合 3 | print(a) #每次输出是不一样的，如输出：{'a', 'd', 'e', 'c', 'b'} 4 | b=[1,2,2,2,3,5,6,6] 5 | c=set(b) #转化为集合，去掉重复元素 6 | print(list(c)) #显示去掉重复元素列表，输出：[1, 2, 3, 5, 6] 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_14.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_14.py 2 | def square_sum(n, p=2): 3 | result=sum([i**p for i in range(1, n+1)]) 4 | return (n, p, result) 5 | print("1到%d的%d次方和为%d"%square_sum(10)) 6 | print("1到%d的%d次方和为%d"%square_sum(10,3)) 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_15.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_15.py 2 | def add(a,b): s=sum([a,b]); return (a,b,s) 3 | print("%d加%d的和为%d"%add(10,13)) 4 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_16.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_16.py 2 | def add(*args): print(args, end=''); s=sum(args); return(s) 3 | print("的和为%d"%add(10,12,6,8)) 4 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_17.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_17.py 2 | def person(name, age, **kw): 3 | print('name:', name, 'age:', age, 'other:', kw) 4 | 5 | person('Michael', 30) 6 | person('Bob', 35, city='Beijing') 7 | person('Adam', 45, gender='M', job='Engineer') 8 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_18.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_18.py 2 | def fun(a,b): 3 | a, b = b, a; 4 | print("函数内交换数值后：a=%d,\tb=%d"%(a,b)) 5 | a=10; b=15 6 | print("调用函数前的数值：a=%d,\tb=%d"%(a,b)) 7 | print("-----------------------------------") 8 | fun(a,b) #调用函数 9 | print("-----------------------------------") 10 | print("调用函数后的数值：a=%d,\tb=%d"%(a,b)) 11 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_19.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_19.py 2 | def change(data): 3 | data[0], data[1] = data[1], data[0] 4 | print("函数内交换位置后：",end='') 5 | for i in range(2): print("data[%d]=%2d"%(i,data[i]),end='\t') 6 | data=[16, 25] #主程序 7 | print("原始数据为：",end='') 8 | for i in range(2): print("data[%d]=%2d"%(i,data[i]),end='\t') 9 | print("\n-------------------------------------------------------") 10 | change(data) 11 | print("\n-------------------------------------------------------") 12 | print("排序后数据为：",end='') 13 | for i in range(2): print("data[%d]=%2d"%(i,data[i]),end='\t') 14 | 15 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_2.py 2 | print("四书五经") 3 | print("《大学》","《中庸》","《论域》","《孟子》",sep='、') 4 | print("《大学》","《中庸》","《论域》","《孟子》") 5 | print("《大学》","《中庸》","《论域》","《孟子》",end=' ') 6 | print("《诗经》","《尚书》","《礼记》","《易经》","《春秋》") 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_20.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_20.py 2 | def fun(a,b,c): print("三个数的和为：",a+b+c) 3 | seq=[1,2,3]; fun(*seq) #输出：三个数的和为： 6 4 | tup=(1,2,3); fun(*tup) #输出：三个数的和为： 6 5 | dic={1:'a', 2:'b', 3:'c'}; fun(*dic) #输出：三个数的和为： 6 6 | set={1,2,3}; fun(*set) #输出：三个数的和为： 6 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_21.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_21.py 2 | import numpy as np #导入numpy库，相当于大模块，并设置别名为np 3 | import numpy.linalg as LA #导入numpy库下linalg（线性代数）模块，别名为LA 4 | a=np.linspace(0,10,5) #产生0到10之间等间距的5个数 5 | b=LA.norm(a) #求b的模，即向量a的长度 6 | print("a的长度为：%7.4f"%b) 7 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_22.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_22.py 2 | from numpy import random as rd #从numpy库中导入模块random并设置别名为rd 3 | from math import sin, cos #导入模块中的正弦函数和余弦函数 4 | from random import randint 5 | a=rd.randint(0,10,(1,3)) #产生[0,10)的3个元素的随机整数数组 6 | b=randint(0,10) #产生[0,10]上的一个随机整数，不能产生向量 7 | print("sin(b)=%6.4f"%sin(b)) 8 | print("cos(b)=%6.4f"%cos(b)) 9 | 10 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_3.py 2 | name="张三"; age=20 3 | print("%s的年龄是%d"%(name,age)) #输出结果：张三的年龄是20 4 | print("{}的年龄是{}".format(name,age)) #输出结果：张三的年龄是20 5 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_4.py 2 | x1 = 58 + 32 #x1=90 3 | x2 = 89 - 28 #x2=61 4 | x3 = 3 * 12 #x3=36 5 | x4 = 125 / 7 #x4=17.857142857142858 6 | x5 =125 // 7 #整除，x5=17 7 | x6 = 4**3 #4的3次幂，x6=64 8 | x7 = 46 % 5 #求余数，x7=1 9 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_5.py 2 | print (100>2) and (52>41) #输出True 3 | total = 124 4 | value = (total % 4 ==0) and (total % 3 == 0) 5 | print(value) #输出False 6 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_6.py 2 | a=5; b=-6 3 | print(~a, bin(~a), bin(b),sep='、') #输出：-6、-0b110、-0b110 4 | print(5<<2) #输出：20 5 | print(5>>2) #输出：1 6 | print(5&3) #输出：1 7 | print(5|3) #输出：7 8 | print(5^3) #输出：6 9 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_7.py 2 | print(list(range(5))) #输出：[0, 1, 2, 3, 4] 3 | print(list(range(1,6))) #输出：[1, 2, 3, 4, 5] 4 | print(list(range(2,10,2))) #输出：[2, 4, 6, 8] 5 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_8.py 2 | sum=0; number=1 3 | while True: 4 | if number==0: break 5 | number=int(input("数字0结束程序，请输入数字：")) 6 | sum += number 7 | print("目前累加的结果为：%d"%(sum)) 8 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/Pz1_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz1_9.py 2 | a=["张三", "男", 23, "江苏", "硕士", "已婚", ["身高172", "体重70"]] 3 | print(a[0]) #显示第一个元素：张三 4 | print(a[-1]) #显示最后一个元素：['身高172', '体重70'] 5 | print(a[-1][1]) #显示最后一个元素中的第二个元素：体重70 6 | print(a[-3:]) #显示后三个元素 7 | print(a[:3]) #显示前三个元素 8 | print(a[::2]) #显示奇数位置的元素 9 | print(a[0:-1]) #显示第一个元素到倒数第二个元素 10 | -------------------------------------------------------------------------------- /01第1章 Python语言快速入门/__pycache__/FunctionSet.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/01第1章 Python语言快速入门/__pycache__/FunctionSet.cpython-37.pyc -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_12.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_12.txt -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_18_1.txt: -------------------------------------------------------------------------------- 1 | 0.000000000000000000e+00 5.000000000000000000e-01 1.000000000000000000e+00 2 | 1.500000000000000000e+00 2.000000000000000000e+00 2.500000000000000000e+00 3 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_18_2.txt: -------------------------------------------------------------------------------- 1 | 0,0,1 2 | 1,2,2 3 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_19.txt: -------------------------------------------------------------------------------- 1 | 6 2 6 7 4 2 5 9 2 | 4 9 5 3 8 5 8 2 3 | 5 2 1 9 7 4 3 3 4 | 7 6 7 3 9 2 7 1 5 | 2 3 9 5 7 2 6 5 6 | 5 5 2 2 8 1 4 3 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_20.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_20.txt -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_21.txt: -------------------------------------------------------------------------------- 1 | 6 2 6 7 4 2 5 9 60kg 2 | 4 9 5 3 8 5 8 2 55kg 3 | 5 2 1 9 7 4 3 3 51kg 4 | 7 6 7 3 9 2 7 1 43kg 5 | 2 3 9 5 7 2 6 5 41kg 6 | 5 5 2 2 8 1 4 -999 52kg 7 | 35 37 22 32 41 32 43 38 8 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_22.bin: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_23_1.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_23_1.npy -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_23_2.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_23_2.npz -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_25.txt: -------------------------------------------------------------------------------- 1 | Python is very useful. 2 | Programming in Python is very easy. 3 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_26.txt: -------------------------------------------------------------------------------- 1 | Hello World! 2 | HelloWorld! -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_32.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_32.txt -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_33.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_33.xlsx -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pdata2_34.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Pdata2_34.xlsx -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_1.py 2 | import numpy as np #导入模块并命名为np 3 | a = np.array([2,4,8,20,16,30]) #单个列表创建一维数组 4 | #嵌套元组创建二维数组 5 | b = np.array(((1,2,3,4,5),(6,7,8,9,10), 6 | (10,9,1,2,3),(4,5,6,8,9.0))) 7 | print("一维数组：",a) 8 | print("二维数组：\n",b) 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_10.py 2 | import numpy as np 3 | a=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]] 4 | b=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]] 5 | print(a.reshape(4,),'\n',a) #输出：[0 1 2 3]和[[0,1],[2,3]] 6 | print(b.resize(4,),'\n',b) #输出：None和[0 1 2 3] 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_11.py 2 | import numpy as np 3 | a=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]] 4 | b=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]] 5 | c=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]] 6 | print(a.reshape(-1),'\n',a) #输出：[0 1 2 3]和[[0,1],[2,3]] 7 | print(b.ravel(),'\n',b) #输出：[0 1 2 3]和[[0,1],[2,3]] 8 | print(c.flatten(),'\n',c) #输出：[0 1 2 3]和[[0,1],[2,3]] 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_12.py 2 | import numpy as np 3 | a=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]] 4 | b=np.arange(4,8).reshape(2,2) #生成数组[[4,5],[6,7]] 5 | c1=np.vstack([a,b]) #垂直方向组合 6 | c2=np.r_[a,b] #垂直方向组合 7 | d1=np.hstack([a,b]) #水平方向组合 8 | d2=np.c_[a,b] #水平方向组合 9 | 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_13.py 2 | import numpy as np 3 | a=np.arange(4).reshape(2,2) #构造2行2列的矩阵 4 | b=np.hsplit(a,2) #把a平均分成2个列数组 5 | c=np.vsplit(a,2) #把a平均分成2个行数组 6 | print(b[0],'\n',b[1],'\n',c[0],'\n',c[1]) 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_14.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_14.py 2 | import numpy as np 3 | a=np.arange(10,15); b=np.arange(5,10) 4 | c=a+b; d=a*b #对应元素相加和相乘 5 | e1=np.modf(a/b)[0] #对应元素相除的小数部分 6 | e2=np.modf(a/b)[1] #对应元素相除的整数部分 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_15.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_15.py 2 | import numpy as np 3 | a=np.array([[3,4,9],[12,15,1]]) 4 | b=np.array([[2,6,3],[7,8,12]]) 5 | print(a[a>b]) #取出a大于b的所有元素，输出：[ 3 9 12 15] 6 | print(a[a>10]) #取出a大于10的所有元素，输出：[12 15] 7 | print(np.where(a>10,-1,a)) #a中大于10的元素改为1 8 | print(np.where(a>10,-1,0)) #a中大于10的元素改为1，否则为0 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_16.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_16.py 2 | import numpy as np, time, math 3 | x=[i*0.01 for i in range(1000000)] 4 | start=time.time() #从公元纪年开始计时，到当前的秒 5 | for (i,t) in enumerate(x): x[i]=math.sin(t) 6 | print("math.sin:", time.time()-start) 7 | y=np.array([i*0.01 for i in range(1000000)]) 8 | start=time.time() 9 | y=np.sin(y) 10 | print("numpy.sin:", time.time()-start) 11 | 12 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_17.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_17.py 2 | import numpy as np 3 | a=np.arange(0, 20, 10).reshape(-1, 1) #变形为1列的数组，行数自动计算 4 | b=np.arange(0, 3) 5 | print(a+b) 6 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_18.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_18.py 2 | import numpy as np 3 | a=np.arange(0,3,0.5).reshape(2,3) #生成2×3的数组 4 | np.savetxt("Pdata2_18_1.txt", a) #缺省按照'%.18e'格式保存数值，以空格分隔 5 | b=np.loadtxt("Pdata2_18_1.txt") #返回浮点型数组 6 | print("b=",b) 7 | np.savetxt("Pdata2_18_2.txt", a, fmt="%d", delimiter=",") #保存为整型数据，以逗号分隔 8 | c=np.loadtxt("Pdata2_18_2.txt",delimiter=",") #读入的时候也需要指定逗号分隔 9 | print("c=",c) 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_19.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_19.py 2 | import numpy as np 3 | a=np.loadtxt("Pdata2_19.txt") #返回值a为浮点型数据 4 | b=a[0:2,1:4] #获取a矩阵的第1,2行，第2,3,4列 5 | print("b=",b) 6 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_2.py 2 | import numpy as np 3 | a=np.arange(4,dtype=float) #创建浮点型数组：[0. 1. 2. 3.] 4 | b=np.arange(0,10,2,dtype=int) #创建整型数组：[0, 2, 4, 6, 8] 5 | c=np.empty((2,3),int) #创建2×3的整型空矩阵 6 | d=np.linspace(-1,2,5) #创建数组：[-1., -0.25, 0.5, 1.25, 2.] 7 | e=np.random.randint(0,3,(2,3)) #生成[0,3)上的2行3列的随机整数数组 8 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_20.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_20.py 2 | import numpy as np 3 | a=np.loadtxt("Pdata2_20.txt",dtype=str,delimiter="，") 4 | b=a[1:,1:].astype(float) #提取a矩阵的数值行和数值列，并转换类型 5 | print("b=",b) 6 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_21.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_21.py 2 | import numpy as np 3 | #读前6行前8列数据 4 | a=np.genfromtxt("Pdata2_21.txt",max_rows=6, usecols=range(8)) 5 | b=np.genfromtxt("Pdata2_21.txt",dtype=str,max_rows=6,usecols=[8]) #读第9列数据 6 | b=[float(v.rstrip('kg')) for (i,v) in enumerate(b)] #删除kg,并转换为浮点型数据 7 | c=np.genfromtxt("Pdata2_21.txt",skip_header=6) #读最后一行数据 8 | print(a,'\n',b,'\n',c) 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_22.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_22.py 2 | import numpy as np 3 | a=np.arange(6).reshape(2,3) 4 | a.tofile('Pdata2_22.bin') 5 | b=np.fromfile('Pdata2_22.bin',dtype=int).reshape(2,3) 6 | print(b) 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_23.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_23.py 2 | import numpy as np 3 | a=np.arange(6).reshape(2,3) 4 | np.save("Pdata2_23_1.npy",a) 5 | b=np.load("Pdata2_23_1.npy") 6 | 7 | c=np.arange(6,12).reshape(2,3) 8 | d=np.sin(c) 9 | np.savez("Pdata2_23_2.npz",c,d) 10 | e=np.load("Pdata2_23_2.npz") 11 | f1=e["arr_0"] #提取第一个数组的数据 12 | f2=e["arr_1"] #提取第二个数组的数据 13 | 14 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_24.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_24.py 2 | f=open("Pdata2_12.txt","w") 3 | print("Name of the file:",f.name) 4 | print("Closed or not:",f.closed) 5 | print("Opening mode:",f.mode) 6 | f.close() 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_25.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_25.py 2 | f=open("Pdata2_25.txt","r") 3 | s=f.read() 4 | print(s) #显示文件内容 5 | n=0 6 | for c in s: 7 | if c in "aeiouAEIOU": n+=1 8 | print("元音的个数为：",n) 9 | 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_26.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_26.py 2 | f1=open("Pdata2_26.txt","w") 3 | str1=['Hello',' ','World!']; str2=['Hello','World!'] 4 | f1.writelines(str1); f1.write('\n') 5 | f1.writelines(str2); f1.close() 6 | f2=open('Pdata2_26.txt') 7 | a=f2.read(); print(a) 8 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_27.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_27.py 2 | import numpy as np 3 | a = []; b = []; c = [] 4 | with open('Pdata2_21.txt') as file: 5 | for (i, line) in enumerate(file): 6 | elements = line.strip().split() 7 | if i < 6: 8 | a.append(list(map(float, elements[:8]))) 9 | b.append(float(elements[-1].rstrip('kg'))) 10 | else: 11 | c = [float(x) for x in elements] 12 | a = np.array(a); b = np.array(b); c = np.array(c) 13 | print(a,'\n',b,'\n',c) 14 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_28.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_28.py 2 | import os 3 | a=os.listdir("c:\\") 4 | print(a) #显示C根目录下的文件和目录列表 5 | print("-------------------------------------") 6 | b=os.listdir(".") 7 | print(b) #显示当前工作目录下的文件和目录列表 8 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_29.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_29.py 2 | import pandas as pd 3 | import numpy as np 4 | s1=pd.Series(np.array([10.5,20.5,30.5])) #由数组构造序列 5 | s2=pd.Series({"北京":10.5,"上海":20.5,"广东":30.5}) #由字典构造序列 6 | s3= pd.Series([10.5,20.5,30.5],index=['b','c','d']) #给出行标签命名 7 | print(s1); print("--------------"); print(s2) 8 | print("--------------"); print(s3) 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_3.py 2 | import numpy as np 3 | a=np.linspace(0,2,5) #生成数组：[0., 0.5, 1., 1.5, 2.] 4 | b=np.mgrid[0:2:5j] #等价于np.linspace(0,2,5) 5 | x,y=np.mgrid[0:2:4j,10:20:5j] #生成[0,2]×[10,20]上的4×5的二维数组 6 | print("x={}\ny={}".format(x,y)) 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_30.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_30.py 2 | import pandas as pd 3 | import numpy as np 4 | s=pd.Series([10.5,20.5,98], 5 | index=['a','b','c']) 6 | a=s['b'] #取出序列的第2个元素，输出：20.5 7 | b1=np.mean(s) #输出：43.0 8 | b2=s.mean() #通过数列方法求均值，输出：43.0 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_31.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_31.py 2 | import pandas as pd 3 | import numpy as np 4 | a=np.arange(1,7).reshape(3,2) 5 | df1=pd.DataFrame(a) 6 | df2=pd.DataFrame(a,index=['a','b','c'], columns=['x1','x2']) 7 | df3=pd.DataFrame({'x1':a[:,0],'x2':a[:,1]}) 8 | print(df1); print("---------"); print(df2) 9 | print("---------"); print(df3) 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_32.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_32.py 2 | import pandas as pd 3 | a=pd.read_csv("Pdata2_32.txt",sep=',',parse_dates={'birthday':[0,1,2]}, 4 | #parse_dates参数通过字典实现前三列的日期解析，并合并为新字段birthday 5 | skiprows=2,skipfooter=2,comment='#',thousands='&',engine='python') 6 | print(a) 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_33.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_33.py 2 | import pandas as pd 3 | a=pd.read_excel("Pdata2_33.xlsx",usecols=range(1,4)) #提取第1列到第4列的数据 4 | b=a.values #提取其中的数据 5 | c=a.describe() #对数据进行统计描述 6 | print(c) 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_34.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_34.py 2 | import pandas as pd 3 | import numpy as np 4 | a=pd.read_excel("Pdata2_33.xlsx",usecols=range(1,4)) #提取第1列到第4列的数据 5 | b=a.values #提取其中的数据 6 | #生成DataFrame类型数据 7 | c=pd.DataFrame(b,index=np.arange(1,11),columns=["用户A","用户B","用户C"]) 8 | f=pd.ExcelWriter('Pdata2_34.xlsx') #创建文件对象 9 | c.to_excel(f,"sheet1") #把c写入Excel文件 10 | c.to_excel(f,"sheet2") #c再写入另一个表单中 11 | f.save() 12 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_35.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_35.py 2 | import pandas as pd 3 | import numpy as np 4 | a=pd.read_excel("Pdata2_33.xlsx",usecols=range(1,4)) #提取第1列到第4列的数据 5 | b1=a.iloc[np.arange(6),[0,1]] #通过标号筛选数据 6 | b2=a.loc[np.arange(6),["用户A","用户B"]] #通过标签筛选数据 7 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_36.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_36.py 2 | import numpy as np, pandas as pd 3 | from matplotlib.pyplot import * 4 | a=pd.read_excel("Pdata2_33.xlsx",usecols=range(1,4)) #提取第2列到第4列的数据 5 | c=np.sum(a) #求每一列的和 6 | ind=np.array([1,2,3]); width=0.2 7 | rc('font',size=16); bar(ind,c,width); ylabel("消费数据") 8 | xticks(ind,['用户A','用户B','用户C'],rotation=20) #旋转20度 9 | rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签 10 | savefig('figure2_36.png',dpi=500) #保存图片为文件figure2_36.png，像素为500 11 | show() 12 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_37.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_37.py 2 | import numpy as np 3 | from matplotlib.pyplot import * 4 | x=np.array(range(8)) 5 | y='27.0 26.8 26.5 26.3 26.1 25.7 25.3 24.8' #数据是粘贴过来的 6 | y=",".join(y.split()) #把空格替换成逗号 7 | y=np.array(eval(y)) #数据之间加逗号太麻烦，我们用程序转换 8 | scatter(x,y) 9 | savefig('figure2_23.png',dpi=500); show() 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_38.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_38.py 2 | import numpy as np 3 | from matplotlib.pyplot import * 4 | x=np.linspace(0,2*np.pi,200) 5 | y1=np.sin(x); y2=np.cos(pow(x,2)) 6 | rc('font',size=16); rc('text', usetex=True) #调用tex字库 7 | plot(x,y1,'r',label='$sin(x)$',linewidth=2) #Latex格式显示公式 8 | plot(x,y2,'b--',label='$cos(x^2)$') 9 | xlabel('$x$'); ylabel('$y$',rotation=0) 10 | savefig('figure2_38.png',dpi=500); legend(); show() 11 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_39.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_39.py 2 | import numpy as np 3 | from matplotlib.pyplot import * 4 | x=np.linspace(0,2*np.pi,200) 5 | y1=np.sin(x); y2=np.cos(x); y3=np.sin(x*x) 6 | rc('font',size=16); rc('text', usetex=True) #调用tex字库 7 | ax1=subplot(2,2,1) #新建左上1号子窗口 8 | ax1.plot(x,y1,'r',label='$sin(x)$') #画图 9 | legend() #添加图例 10 | ax2=subplot(2,2,2) #新建右上2号子窗口 11 | ax2.plot(x,y2,'b--',label='$cos(x)$'); legend() 12 | ax3=subplot(2,1,2) #新建两行、1列的下面子窗口 13 | ax3.plot(x,y3,'k--',label='$sin(x^2)$'); legend(); 14 | savefig('figure2_39.png',dpi=500); show() 15 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_4.py 2 | import numpy as np 3 | a=np.random.randint(1,11,(3,5)) #生成[1,11 )区间上3行5列的随机整数数组 4 | print("维数：",a.ndim); #维数：2 5 | print("维度：",a.shape) #维度：（3,5） 6 | print("元素总数：",a.size); #元素总数：15 7 | print("类型：",a.dtype) #类型：int32 8 | print("每个元素字节数：",a.itemsize) #字节数：4 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_40.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_40.py 2 | from mpl_toolkits import mplot3d 3 | import matplotlib.pyplot as plt 4 | import numpy as np 5 | ax=plt.axes(projection='3d') #设置三维图形模式 6 | z=np.linspace(0, 100, 1000) 7 | x=np.sin(z)*z; y=np.cos(z)*z 8 | ax.plot3D(x, y, z, 'k') 9 | plt.savefig('figure2_40.png',dpi=500); plt.show() 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_41.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_41.py 2 | from mpl_toolkits import mplot3d 3 | import matplotlib.pyplot as plt 4 | import numpy as np 5 | x=np.linspace(-6,6,30) 6 | y=np.linspace(-6,6,30) 7 | X,Y=np.meshgrid(x, y) 8 | Z= np.sin(np.sqrt(X ** 2 + Y ** 2)) 9 | ax1=plt.subplot(1,2,1,projection='3d') 10 | ax1.plot_surface(X, Y, Z,cmap='viridis') 11 | ax1.set_xlabel('x'); ax1.set_ylabel('y'); ax1.set_zlabel('z') 12 | ax2=plt.subplot(1,2,2,projection='3d'); 13 | ax2.plot_wireframe(X, Y, Z,color='c') 14 | ax2.set_xlabel('x'); ax2.set_ylabel('y'); ax2.set_zlabel('z') 15 | plt.savefig('figure2_41.png',dpi=500); plt.show() 16 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_42_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_42_1.py 2 | from mpl_toolkits import mplot3d 3 | import matplotlib.pyplot as plt 4 | import numpy as np 5 | z=np.loadtxt("Pdata2_42.txt") #加载高程数据 6 | x=np.arange(0,1500,100) 7 | y=np.arange(1200,-10,-100) 8 | contr=plt.contour(x,y,z); plt.clabel(contr) #画等高线并标注 9 | plt.xlabel('$x$'); plt.ylabel('$y$',rotation=0) 10 | plt.savefig('figure2_42_1.png',dpi=500) 11 | plt.figure() #创建一个绘图对象 12 | ax=plt.axes(projection='3d') #用这个绘图对象创建一个三维坐标轴对象 13 | X,Y=np.meshgrid(x,y) 14 | ax.plot_surface(X, Y, z,cmap='viridis') 15 | ax.set_xlabel('x'); ax.set_ylabel('y'); ax.set_zlabel('z') 16 | plt.savefig('figure2_42_2.png',dpi=500); plt.show() 17 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_42_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_28_2.py 2 | from mpl_toolkits import mplot3d 3 | import matplotlib.pyplot as plt 4 | import numpy as np 5 | z=np.loadtxt("Pdata2_42.txt") #加载高程数据 6 | x=np.arange(0,1500,100) 7 | y=np.arange(1200,-10,-100) 8 | ax1=plt.subplot(1,2,1) 9 | contr=plt.contour(x,y,z); plt.clabel(contr) #画等高线并标注 10 | plt.xlabel('$x$'); plt.ylabel('$y$',rotation=0) 11 | ax2=plt.subplot(1,2,2,projection='3d') 12 | plt.sca(ax2) 13 | X,Y=np.meshgrid(x,y) 14 | ax2.plot_surface(X, Y, z,cmap='viridis') 15 | ax2.set_xlabel('x'); ax2.set_ylabel('y'); ax2.set_zlabel('z') 16 | plt.savefig('figure2_42_2.png',dpi=500); plt.show() 17 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_43.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_43.py 2 | import matplotlib.pyplot as plt 3 | from numpy import * 4 | x=linspace(0,15,11); y=linspace(0,10,12) 5 | x,y=meshgrid(x,y) #生成网格数据 6 | v1=y*cos(x); v2=y*sin(x) 7 | plt.quiver(x,y,v1,v2) 8 | plt.savefig('figure2_43.png',dpi=500); plt.show() 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_44.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_34.py 2 | import numpy as np 3 | from matplotlib.pyplot import * 4 | x=np.linspace(0,2*np.pi,200) 5 | y1=np.sin(x); y2=np.cos(x); y3=np.sin(x*x); y4=x*np.sin(x) 6 | rc('font',size=16); rc('text', usetex=True) #调用tex字库 7 | ax1=subplot(2,3,1) #新建左上1号子窗口 8 | ax1.plot(x,y1,'r',label='$sin(x)$') #画图 9 | legend() #添加图例 10 | ax2=subplot(2,3,2) #新建2号子窗口 11 | ax2.plot(x,y2,'b--',label='$cos(x)$'); legend() 12 | ax3=subplot(2,3,(3,6)) #3、6子窗口合并 13 | ax3.plot(x,y3,'k--',label='$sin(x^2)$'); legend() 14 | ax4=subplot(2,3,(4,5)) #4、5号子窗口合并 15 | ax4.plot(x,y4,'k--',label='$xsin(x)$'); legend() 16 | savefig('figure2_44.png',dpi=500); show() 17 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_46.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_46.py 2 | from matplotlib.pyplot import plot, legend, xlabel, ylabel, savefig, show, rc 3 | from scipy.stats import gamma 4 | from numpy import linspace 5 | x=linspace(0,15,100); rc('font',size=15); rc('text', usetex=True) 6 | plot(x,gamma.pdf(x,4,0,2),'r*-',label="$\\alpha=4, \\beta=2$") 7 | plot(x,gamma.pdf(x,4,0,1),'bp-',label="$\\alpha=4, \\beta=1$") 8 | plot(x,gamma.pdf(x,4,0,0.5),'.k-',label="$\\alpha=4, \\beta=0.5$") 9 | plot(x,gamma.pdf(x,2,0,0.5),'>g-',label="$\\alpha=2, \\beta=0.5$") 10 | legend(); xlabel('$x$'); ylabel('$f(x)$') 11 | savefig("figure2_46.png",dpi=500); show() 12 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_47.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_47.py 2 | import matplotlib.pyplot as plt 3 | import numpy as np 4 | from scipy.stats import norm 5 | mu0 = [-1, 0]; s0 = [0.5, 1] 6 | x = np.linspace(-7, 7, 100); plt.rc('font',size=15) 7 | plt.rc('text', usetex=True); plt.rc('axes',unicode_minus=False) 8 | f, ax = plt.subplots(len(mu0), len(s0), sharex=True, sharey=True) 9 | for i in range(2): 10 | for j in range(2): 11 | mu = mu0[i]; s = s0[j] 12 | y = norm(mu, s).pdf(x) 13 | ax[i,j].plot(x, y) 14 | ax[i,j].plot(1,0,label="$\\mu$ = {:3.2f}\n$\\sigma$ = {:3.2f}".format(mu,s)) 15 | ax[i,j].legend(fontsize=12) 16 | ax[1,1].set_xlabel('$x$') 17 | ax[0,0].set_ylabel('pdf($x$)') 18 | plt.savefig('figure2_47.png'); plt.show() 19 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_48_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_48_1.py 2 | from scipy.stats import binom 3 | import matplotlib.pyplot as plt 4 | import numpy as np 5 | n, p=5, 0.4 6 | x=np.arange(6); y=binom.pmf(x,n,p) 7 | plt.subplot(121); plt.plot(x, y, 'ro') 8 | plt.vlines(x, 0, y, 'k', lw=3, alpha=0.5) #vlines(x, ymin, ymax)画竖线图 9 | #lw设置线宽度，alpha设置图的透明度 10 | plt.subplot(122); plt.stem(x, y, use_line_collection=True) 11 | plt.savefig("figure2_48.png", dpi=500); plt.show() 12 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_48_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_48_2.py 2 | from scipy.stats import binom 3 | import pylab as plt 4 | n, p=5, 0.4 5 | x=plt.arange(6); y=binom.pmf(x,n,p) 6 | plt.subplot(121); plt.plot(x, y, 'ro') 7 | plt.vlines(x, 0, y, 'k', lw=3, alpha=0.5) #vlines(x, ymin, ymax)画竖线图 8 | #lw设置线宽度，alpha设置图的透明度 9 | plt.subplot(122); plt.stem(x, y, use_line_collection=True) 10 | plt.show() 11 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_5.py 2 | import numpy as np 3 | a=np.array([1,2,3]) 4 | print("维度为：",a.shape) #维度为：（3,) 5 | b=np.array([[1,2,3]]) 6 | print("维度为：",b.shape) #维数为：（1,3） 7 | c=np.array([[1],[2],[3]]) 8 | print("维度为：",c.shape) #维度为：（3,1） 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_6.py 2 | import numpy as np 3 | a = np.array([2,4,8,20,16,30]) 4 | b = np.array(((1,2,3,4,5),(6,7,8,9,10), 5 | (10,9,1,2,3),(4,5,6,8,9.0))) 6 | print(a[[2,3,5]]) #一维数组索引，输出：[ 8 20 30] 7 | print(a[[-1,-2,-3]]) #一维数组索引，输出：[30 16 20] 8 | print(b[1,2]) #输出第2行第3列元素：8.0 9 | print(b[2]) #输出第3行元素：[10. 9. 1. 2. 3.] 10 | print(b[2,:]) #输出第3行元素：[10. 9. 1. 2. 3.] 11 | print(b[:,1]) #输出第2列所有元素：[2. 7. 9. 5.] 12 | print(b[[2,3],1:4]) #输出第3、4行，第2、3、4列的元素 13 | print(b[1:3,1:3]) #输出第2、3行，第2、3列的元素 14 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_7.py 2 | from numpy import array, nan, isnan 3 | a=array([[1, nan, 2], [4, nan, 3]]) 4 | b=a[~isnan(a)] #提取a中非nan的数 5 | print("b=",b) 6 | print("b中大于2的元素有：", b[b>2]) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_8.py 2 | from numpy import array 3 | x = array([[1,2],[3,4],[5,6]]) 4 | print("前两行元素为：\n", x[[0,1]]) #输出：[[1,2],[3,4]] 5 | print("x[0][0]和x[1][1]为：", x[[0,1],[0,1]]) #输出：[1 4] 6 | print("以下两种格式是一样的：") 7 | print(x[[0,1]][:,[0,1]]) # 输出：[[1,2],[3,4]]， 8 | print(x[0:2,0:2]) #同上，输出第1、2行，第1、2列的元素 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Pex2_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex2_9.py 2 | import numpy as np 3 | x = np.array([[1,2],[3,4],[5,6]]) 4 | x[2,0] = -1 #修改第3行、第1列元素为-1 5 | y=np.delete(x,2,axis=0) #删除数组的第3行 6 | z=np.delete(y,0, axis=1) #删除数组的第1列 7 | t1=np.append(x,[[7,8]],axis=0) #增加一行 8 | t2=np.append(x,[[9],[10],[11]],axis=1) #增加一列 9 | -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/Trade.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/Trade.xlsx -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_23.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_23.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_36.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_36.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_38.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_38.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_39.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_39.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_40.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_40.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_41.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_41.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_42_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_42_1.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_42_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_42_2.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_43.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_43.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_44.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_44.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_45.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_45.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_46.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_46.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_47.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_47.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/figure2_48.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/figure2_48.png -------------------------------------------------------------------------------- /02第2章 数据处理与可视化/附件1：区域高程数据.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/02第2章 数据处理与可视化/附件1：区域高程数据.xlsx -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_1.py 2 | from sympy import * 3 | x,y,z=symbols('x y z') 4 | m0,m1,m2,m3=symbols('m0:4') #创建多个符号变量 5 | x=sin(1) 6 | print("x=",x); print("x=",x.evalf()) 7 | print("x=",x.n(16)) #显示小数点后16位数字 8 | print("pi的两种显示格式:{},{}".format(pi,pi.evalf(3))) #这里不能使用n()函数 9 | expr1=y*sin(y**2) #创建第一个符号表达式 10 | expr2=y**2+sin(y)*cos(y)+sin(z) #创建第二个符号表达式 11 | print("expr1=",expr1) 12 | print("y=5时，expr1=",expr1.subs(y,5)) #代入一个符号变量的值 13 | print("y=2,z=3时，expr2=",expr2.subs({y:2,z:3})) #代入y=2,z=3 14 | print("y=2,z=3时，expr2=",expr2.subs({y:2,z:3}).n()) #以浮点数显示计算结果 15 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_10.py 2 | from sympy import integrate, symbols, sin, pi, oo 3 | x=symbols('x') 4 | print(integrate(sin(2*x),(x,0,pi))) 5 | print(integrate(sin(x)/x,(x,0,oo))) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_11.py 2 | from sympy import * 3 | x,y=symbols('x y') 4 | print(solve(x**3-1,x)) 5 | print(solve((x-2)**2*(x-1)**3,x)) 6 | print(roots((x-2)**2*(x-1)**3,x)) #roots可以得到根的重数信息 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_12.py 2 | from sympy.abc import x, y 3 | from sympy import solve 4 | s=solve([x**2+y**2-1, x-y], [x, y]) 5 | print("方程组的解为：", s) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_13.py 2 | from sympy import * 3 | x=symbols('x'); y=2*x**3-5*x**2+x 4 | x0=solve(diff(y,x),x) #求驻点 5 | print("驻点的精确解为",x0) 6 | print("驻点的浮点数表示为：",[x0[i].n() for i in range(len(x0))]) #列表中的符号数无法整体转换为浮点数 7 | y0=[y.subs(x,0),y.subs(x,1),y.subs(x,x0[0]).n()] #代入区间端点和一个驻点的值 8 | print("三个点的函数值分别为:",y0) 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_14.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_14.py 2 | from sympy import * 3 | x=symbols('x'); y=symbols('y',cls=Function) 4 | eq1=diff(y(x),x,2)-5*diff(y(x),x)+6*y(x) 5 | eq2=diff(y(x),x,2)-5*diff(y(x),x)+6*y(x)-x*exp(2*x) 6 | print("齐次方程的解为：",dsolve(eq1,y(x))) 7 | print("非齐次方程的解为：",dsolve(eq2,y(x))) 8 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_15.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_15.py 2 | from sympy import * 3 | x=symbols('x'); y=symbols('y',cls=Function) 4 | eq1=diff(y(x),x,2)-5*diff(y(x),x)+6*y(x) 5 | eq2=diff(y(x),x,2)-5*diff(y(x),x)+6*y(x)-x*exp(2*x) 6 | print("初值问题的解为：{}".format(dsolve(eq1,y(x),ics={y(0):1,diff(y(x),x).subs(x,0):0}))) 7 | y2=dsolve(eq2,y(x),ics={y(0):1,y(2):0}) 8 | print("边值问题的解为：{}".format(y2)) 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_16.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_16.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | def fac(n): return (1 if n<1 else n*fac(n-1)) 5 | def item(n,x): return (-1)**n*x**(2*n+1)/fac(2*n+1) 6 | def mysin(n,x): return (0 if n<0 else mysin(n-1,x)+item(n,x)) 7 | x=np.linspace(-2*np.pi,2*np.pi,101) 8 | plt.plot(x,np.sin(x),'*-') 9 | str=['v-','H--','-.'] 10 | for n in [1,2,3]: plt.plot(x,mysin(2*n-1,x),str[n-1]) 11 | plt.legend(['sin','n=1','n=3','n=5']) 12 | plt.savefig('figure3_16.png',dpi=500); plt.show() 13 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_17.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_17.py 2 | import numpy as np, numpy.linalg as ng 3 | import matplotlib.pyplot as plt 4 | N=4; v=1.0; d=200.0; time=400.0; divs=201 5 | xy=np.array([[-d,d],[d,d],[d,-d],[-d,-d]]) 6 | T=np.linspace(0,time,divs); dt=T[1]-T[0] 7 | xyn=np.empty((4,2)); Txy=xy 8 | for n in range(1,len(T)): 9 | for i in [0,1,2,3]: 10 | j=(i+1)%4; dxy=xy[j]-xy[i] 11 | dd=dxy/ng.norm(dxy) #单位化向量 12 | xyn[i]=xy[i]+v*dt*dd; #计算下一步的位置 13 | Txy=np.c_[Txy,xyn]; xy=xyn 14 | for i in range(N):plt.plot(Txy[i,::2],Txy[i,1::2]) 15 | plt.savefig("figure3_17.png",dpi=500); plt.show() 16 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_18.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_18.py 2 | import numpy as np 3 | from scipy.integrate import quad 4 | 5 | def trapezoid(f,n,a,b): #定义梯形公式的函数 6 | xi=np.linspace(a,b,n); h=(b-a)/(n-1) 7 | return h*(np.sum(f(xi))-(f(a)+f(b))/2) 8 | 9 | def simpson(f,n,a,b): #定义辛普森公式的函数 10 | xi, h=np.linspace(a,b,2*n+1), (b-a)/(2.0*n) 11 | xe=[f(xi[i]) for i in range(len(xi)) if i%2==0] 12 | xo=[f(xi[i]) for i in range(len(xi)) if i%2!=0] 13 | return h*(2*np.sum(xe)+4*np.sum(xo)-f(a)-f(b))/3.0 14 | 15 | a=0; b=1; n=1000 16 | f=lambda x: np.sin(np.sqrt(np.cos(x)+x**2)) 17 | 18 | print("梯形积分I1=",trapezoid(f,n,a,b)) 19 | print("辛普森积分I2=",simpson(f,n,a,b)) 20 | print("SciPy积分I3=",quad(f,a,b)) 21 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_19.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_19.py 2 | import numpy as np 3 | from scipy.integrate import dblquad 4 | 5 | f1=lambda y, x: x*y**2 #第一个被积函数 6 | print("I1：",dblquad(f1, 0, 2, 0, 1)) 7 | 8 | f2=lambda y, x: np.exp(-x**2/2)*np.sin(x**2+y) 9 | bd=lambda x: np.sqrt(1-x**2) 10 | print("I2:",dblquad(f2, -1, 1, lambda x: -bd(x), bd)) 11 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_2.py 2 | from sympy import * 3 | x1,x2,x3,x4=symbols('m1:5'); x=symbols('x') 4 | print(x1/x2+x3/x4) 5 | print(together(x1/x2+x3/x4)) 6 | print((2*x**2+3*x+4)/(x+1)) 7 | print(simplify((2*x**2+3*x+4)/(x+1))) #化简没有效果 8 | print(apart((2*x**2+3*x+4)/(x+1))) 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_20.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_20.py 2 | import numpy as np 3 | from scipy.integrate import tplquad 4 | f=lambda z, y, x: z*np.sqrt(x**2+y**2+1) 5 | ybd=lambda x: np.sqrt(2*x-x**2) 6 | print("I=",tplquad(f, 0, 2, lambda x: -ybd(x),ybd, 0, 6)) 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_21.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_21.py 2 | import numpy as np 3 | from scipy.optimize import fsolve 4 | 5 | def binary_search(f, eps, a, b): #二分法函数 6 | c=(a+b)/2 7 | while np.abs(f(c))>eps: 8 | if f(a)*f(c)<0: b=c 9 | else: a=c 10 | c=(a+b)/2 11 | return c 12 | 13 | def newton_iter(f, eps, x0, dx=1E-8): #牛顿迭代法函数 14 | def diff(f, dx=dx): #求数值导数函数 15 | return lambda x: (f(x+dx)-f(x-dx))/(2*dx) 16 | df=diff(f,dx) 17 | x1=x0-f(x0)/df(x0) 18 | while np.abs(x1-x0)>=eps: 19 | x1, x0=x1-f(x1)/df(x1), x1 20 | return x1 21 | 22 | f=lambda x: x**3+1.1*x**2+0.9*x-1.4 23 | print("二分法求得的根为：", binary_search(f,1E-6,0,1)) 24 | print("牛顿迭代法求得的根为：",newton_iter(f,1E-6,0)) 25 | print("直接调用SciPy求得的根为：",fsolve(f,0)) 26 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_22_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_22_1.py 2 | from numpy import sin 3 | from scipy.optimize import fsolve 4 | f=lambda x: [5*x[1]+3, 4*x[0]**2-2*sin(x[1]*x[2]), x[1]*x[2]-1.5] 5 | print("result=",fsolve(f, [1.0, 1.0, 1.0])) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_22_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_22_2.py 2 | from numpy import sin 3 | from scipy.optimize import fsolve 4 | def Pfun(x): 5 | x1,x2,x3=x.tolist() #x转换成列表 6 | return 5*x2+3, 4*x1**2-2*sin(x2*x3), x2*x3-1.5 7 | print("result=",fsolve(Pfun, [1.0, 1.0, 1.0])) 8 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_23.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_23.py 2 | from numpy import exp,cos 3 | from scipy.optimize import fminbound 4 | f=lambda x: exp(x)*cos(2*x) 5 | x0=fminbound(f,0,3) 6 | print("极小点为：{}，极小值为：{}".format(x0,f(x0))) 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_24.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_24.py 2 | from numpy import exp,cos 3 | from scipy.optimize import fmin 4 | f=lambda x: exp(x)*cos(2*x) 5 | x0=fmin(f,0) 6 | print("极小点为：{}，极小值为：{}".format(x0,f(x0))) 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_25.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_25.py 2 | from scipy.optimize import minimize 3 | f=lambda x: 100*(x[1]-x[0]**2)**2+(1-x[0])**2; 4 | x0=minimize(f,[2.0, 2.0]) 5 | print("极小点为：{}，极小值为：{}".format(x0.x,x0.fun)) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_26.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_26.py 2 | import sympy as sp 3 | A=sp.Matrix([[1],[2],[3]]) #列向量,即3×1矩阵 4 | B=sp.Matrix([[4],[5],[6]]) 5 | print("A的模为：",A.norm()) 6 | print("A的模的浮点数为：",A.norm().evalf()) 7 | print("A的转置矩阵为：",A.T) 8 | print("A和B的点乘为：",A.dot(B)) 9 | print("A和B的叉乘为：",A.cross(B)) 10 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_27.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_27.py 2 | import sympy as sp 3 | import numpy as np 4 | A=sp.Matrix(np.arange(1,17).reshape(4,4)) 5 | B=sp.eye(4) 6 | print("A的行列式为：",sp.det(A)) 7 | print("A的秩为：",A.rank()) 8 | print("A的转置矩阵为：",A.transpose()) #等价于A.T 9 | print("所求的逆阵为：",(A+10*B).inv()) 10 | print("A的平方为：",A**2) 11 | print("A,B的乘积为：",A*B) 12 | print("横连矩阵为：",A.row_join(B)) 13 | print("纵连矩阵为：",A.col_join(B)) 14 | print("A1为：",A[0:2,0:2]) 15 | A2=A.copy(); A2.row_del(3) 16 | print("A2为：",A2) 17 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_28.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_28.py 2 | import sympy as sp 3 | A=sp.Matrix([[2, 1, -5, 1],[1, -3, 0, -6],[0, 2, -1, 2],[1, 4, -7, 6]]) 4 | b=sp.Matrix([8, 6, -2, 2]); b.transpose() 5 | print("系数矩阵A的秩为：",A.rank()) 6 | print("线性方程组的唯一解为：",A.inv()*b) 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_29.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_29.py 2 | import sympy as sp 3 | A=sp.Matrix([[1, -5, 2, -3],[5, 3, 6, -1], [2, 4, 2, 1]]) 4 | print("A的零空间（即基础解系）为：",A.nullspace()) 5 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_3.py 2 | from sympy.plotting import plot 3 | from sympy.abc import x,pi #引进符号变量x及常量pi 4 | from sympy.functions import sin,cos 5 | plot((2*sin(x),(x,-6,6)),(cos(x+pi/4),(x,-5,5))) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_30.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_30.py 2 | import sympy as sp 3 | A=sp.Matrix([[1, 1, -3, -1],[3, -1, -3, 4], [1, 5, -9, -8]]) 4 | b=sp.Matrix([1, 4, 0]); b.transpose() 5 | C=A.row_join(b) #构造增广矩阵 6 | print("增广阵的行最简形为：\n",C.rref()) 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_31.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_31.py 2 | import sympy as sp 3 | A=sp.Matrix([[0, -2, 2],[-2, -3, 4], [2, 4, -3]]) 4 | print("A的特征值为：",A.eigenvals()) 5 | print("A的特征向量为：",A.eigenvects()) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_32.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_32.py 2 | from sympy import Matrix, diag 3 | A=Matrix([[0, -2, 2],[-2, -3, 4], [2, 4, -3]]) 4 | if A.is_diagonalizable(): print("A的对角化矩阵为：",A.diagonalize()) 5 | else: print("A不能对角化") 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_33.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_33.py 2 | from numpy import arange, cross, inner 3 | from numpy.linalg import norm 4 | a=arange(1,4); b=arange(4,7) #创建数组 5 | print("a的二范数为：",norm(a)) 6 | print("a点乘b=", a.dot(b)) #行向量a乘以列向量b 7 | print("a,b的内积=",inner(a,b)) #a,b的内积,这里与dot(a,b)等价 8 | print("a叉乘b=", cross(a,b)) 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_34.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import numpy.linalg as LA 3 | A=np.arange(1,17).reshape(4,4) 4 | B=np.eye(4) 5 | print("A的行列式为：", LA.det(A)) 6 | print("A的秩为：",LA.matrix_rank(A)) 7 | print("A的转置矩阵为：\n",A.transpose()) #等价于A.T 8 | print("所求的逆阵为：\n",LA.inv(A+10*B)) 9 | print("A的平方为：\n",A.dot(A)) 10 | print("A,B的乘积为：\n",A.dot(B)) 11 | print("横连矩阵为：",np.c_[A,B]) 12 | print("纵连矩阵为：",np.r_[A,B]) 13 | print("A1为：",A[0:2,0:2]) 14 | A2=A.copy(); A2=np.delete(A2,3,axis=0) 15 | print("A2为：",A2) 16 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_35.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_35.py 2 | import numpy as np 3 | from scipy.linalg import null_space 4 | A=np.array([[1, -5, 2, -3],[5, 3, 6, -1], [2, 4, 2, 1]]) 5 | print("A的零空间（即基础解系）为：",null_space(A)) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_36.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_36.py 2 | import numpy as np 3 | import numpy.linalg as LA 4 | A=np.array([[2, 1, -5, 1],[1, -3, 0, -6],[0, 2, -1, 2],[1, 4, -7, 6]]) 5 | b=np.array([[8, 6, -2, 2]]); b=b.reshape(4,1) 6 | print("系数矩阵A的秩为：",LA.matrix_rank(A)) 7 | print("线性方程组的唯一解为：",LA.inv(A).dot(b)) #使用逆矩阵 8 | print("线性方程组的唯一解为：",LA.pinv(A).dot(b)) #使用伪逆 9 | print("线性方程组的唯一解为：",LA.solve(A,b)) #利用solve求解 10 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_37.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_37.py 2 | from numpy import array 3 | from numpy.linalg import pinv 4 | A=array([[1, 1, -3, -1],[3, -1, -3, 4], [1, 5, -9, -8]]) 5 | b=array([1, 4, 0]); b.resize(3,1) 6 | x=pinv(A).dot(b) #求最小范数解 7 | print("最小范数解为：",x) 8 | 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_38.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_38.py 2 | from numpy import array 3 | from numpy.linalg import pinv 4 | A=array([[1, 1],[2, 2], [1, 2]]) 5 | b=array([1, 3, 2]); b.resize(3,1) 6 | x=pinv(A).dot(b) #求最小二乘解 7 | print("最小二乘解为：",x) 8 | 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_39.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_39.py 2 | import numpy as np 3 | from numpy.linalg import eig 4 | A=np.array([[0, -2, 2],[-2, -3, 4], [2, 4, -3]]) 5 | values, vectors=eig(A) 6 | print("A的特征值为：",values) 7 | print("A的特征向量为：",vectors) 8 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_4.py 2 | from pylab import rc #pylab为matplotlib的接口 3 | from sympy.plotting import plot3d 4 | from sympy.abc import x,y #引进符号变量x,y 5 | from sympy.functions import sin,sqrt 6 | rc('font',size=16); rc('text',usetex=True) 7 | plot3d(sin(sqrt(x**2+y**2)),(x,-10,10),(y,-10,10),xlabel='$x$',ylabel='$y$') 8 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_40.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_40.py 2 | from numpy import array, dot 3 | from numpy.linalg import eig,inv 4 | A=array([[0, -2, 2],[-2, -3, 4], [2, 4, -3]]) 5 | values, vectors=eig(A) 6 | check=dot(inv(vectors),A).dot(vectors) 7 | print("check=\n", check) 8 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_41.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_41.py 2 | import numpy as np 3 | import numpy.linalg as LA 4 | from matplotlib.pyplot import plot, rc, legend, show, savefig 5 | x = np.array([0, 1, 2, 3]) 6 | y = np.array([-1, 0.2, 0.9, 2.1]) 7 | A = np.c_[x, np.ones_like(x)] 8 | m, c = LA.lstsq(A, y, rcond=None)[0] 9 | print(m,c); rc('font',size=16) 10 | plot(x, y, 'o', label='原始数据', markersize=5) 11 | plot(x, m*x + c, 'r', label='拟合直线') 12 | rc('font',family='SimHei') #用来正常显示中文标签 13 | rc('axes',unicode_minus=False) #用来正常显示负号 14 | legend(); savefig("figure3_41.png",dpi=500); show() 15 | 16 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_42.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_42.py 2 | import numpy as np 3 | import numpy.linalg as LA 4 | import matplotlib.pyplot as plt 5 | t = np.arange(8) 6 | y=np.array([27.0,26.8,26.5,26.3,26.1,25.7,25.3,24.8]) 7 | A = np.c_[t, np.ones_like(t)] 8 | ab = LA.lstsq(A, y, rcond=None)[0] #返回值为向量 9 | print(ab); plt.rc('font',size=16) 10 | plt.plot(t, y, 'o', label='Original data', markersize=5) 11 | plt.plot(t, A.dot(ab), 'r', label='Fitted line') 12 | plt.legend(); plt.savefig("figure3_42.png",dpi=500); plt.show() 13 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_5_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_5_1.py 2 | from pylab import rc 3 | from sympy import plot_implicit as pt,Eq 4 | from sympy.abc import x,y #引进符号变量x,y 5 | rc('font',size=16); rc('text',usetex=True) 6 | pt(Eq((x-1)**2+(y-2)**3,4),(x,-6,6),(y,-2,4),xlabel='$x$',ylabel='$y$') 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_5_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_5_2.py 2 | from sympy import plot_implicit as pt 3 | from sympy.abc import x,y #引进符号变量x,y 4 | ezplot=lambda expr:pt(expr) 5 | ezplot((x-1)**2+(y-2)**3-4) 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_6.py 2 | from sympy import * 3 | x=symbols('x') 4 | print(limit(sin(x)/x,x,0)) 5 | print(limit(pow(1+1/x,x),x,oo)) #这里是两个小”o”，表示正无穷 6 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_7.py 2 | from sympy import * 3 | x,y=symbols('x y') #定义两个符号变量 4 | z=sin(x)+x**2*exp(y) #构造符号表达式 5 | print("关于x的二阶偏导数为：",diff(z,x,2)) 6 | print("关于y的一阶偏导数为：",diff(z,y)) 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_8.py 2 | from sympy import * 3 | k,n=symbols('k n') 4 | print(summation(k**2,(k,1,n))) 5 | print(factor(summation(k**2,(k,1,n)))) #把计算结果因式分解 6 | print(summation(1/k**2,(k,1,oo))) #这里是两个小o表示正无穷 7 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/Pex3_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex3_9.py 2 | from pylab import rc 3 | from sympy import * 4 | rc('font',size=16); rc('text',usetex=True) 5 | x=symbols('x'); y=sin(x) 6 | for k in range(3,8,2): print(y.series(x,0,k)) #等价于print(series(y,x,0,k)) 7 | plot(y,series(y,x,0,3).removeO(),series(y,x,0,5).removeO(), 8 | series(y,x,0,7).removeO(),(x,0,2),xlabel='$x$',ylabel='$y$') 9 | -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/figure3_16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/03第3章 Python在高等数学和工程数学的应用/figure3_16.png -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/figure3_17.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/03第3章 Python在高等数学和工程数学的应用/figure3_17.png -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/figure3_29.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/03第3章 Python在高等数学和工程数学的应用/figure3_29.png -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/figure3_32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/03第3章 Python在高等数学和工程数学的应用/figure3_32.png -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/figure3_41.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/03第3章 Python在高等数学和工程数学的应用/figure3_41.png -------------------------------------------------------------------------------- /03第3章 Python在高等数学和工程数学的应用/figure3_42.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/03第3章 Python在高等数学和工程数学的应用/figure3_42.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata2_33.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/Pdata2_33.xlsx -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_20.txt: -------------------------------------------------------------------------------- 1 | 15.0 15.8 15.2 15.1 15.9 14.7 14.8 15.5 15.6 15.3 2 | 15.1 15.3 15.0 15.6 15.7 14.8 14.5 14.2 14.9 14.9 3 | 15.2 15.0 15.3 15.6 15.1 14.9 14.2 14.6 15.8 15.2 4 | 15.9 15.2 15.0 14.9 14.8 14.5 15.1 15.5 15.5 15.1 5 | 15.1 15.0 15.3 14.7 14.5 15.5 15.0 14.7 14.6 14.2 6 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_23.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/Pdata4_23.xlsx -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_26_1.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/Pdata4_26_1.xlsx -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_26_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/Pdata4_26_2.xlsx -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_29.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/Pdata4_29.xlsx -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_6_1.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/Pdata4_6_1.xlsx -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_6_2.txt: -------------------------------------------------------------------------------- 1 | 172 75 169 55 169 64 171 65 167 47 2 | 171 62 168 67 165 52 169 62 168 65 3 | 166 62 168 65 164 59 170 58 165 64 4 | 160 55 175 67 173 74 172 64 168 57 5 | 155 57 176 64 172 69 169 58 176 57 6 | 173 58 168 50 169 52 167 72 170 57 7 | 166 55 161 49 173 57 175 76 158 51 8 | 170 63 169 63 173 61 164 59 165 62 9 | 167 53 171 61 166 70 166 63 172 53 10 | 173 60 178 64 163 57 169 54 169 66 11 | 178 60 177 66 170 56 167 54 169 58 12 | 173 73 170 58 160 65 179 62 172 50 13 | 163 47 173 67 165 58 176 63 162 52 14 | 165 66 172 59 177 66 182 69 175 75 15 | 170 60 170 62 169 63 186 77 174 66 16 | 163 50 172 59 176 60 166 76 167 63 17 | 172 57 177 58 177 67 169 72 166 50 18 | 182 63 176 68 172 56 173 59 174 64 19 | 171 59 175 68 165 56 169 65 168 62 20 | 177 64 184 70 166 49 171 71 170 59 21 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pdata4_9.txt: -------------------------------------------------------------------------------- 1 | 2.7 2.8 2.9 3.1 3.1 3.1 3.2 3.4 3.4 3.4 3.4 3.4 3.5 3.5 3.5 3.6 3.7 3.7 3.7 3.8 3.8 4.0 4.1 4.2 4.2 2 | 4.1 4.1 4.3 4.3 4.5 4.6 4.7 4.8 4.8 5.1 5.3 5.3 5.3 5.4 5.4 5.5 5.6 5.7 5.8 5.8 6.0 6.1 6.3 6.7 6.7 -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_1.py 2 | from scipy.stats import norm 3 | from scipy.optimize import fsolve 4 | print("p=",norm.cdf(6,3,5)-norm.cdf(2,3,5)) 5 | f=lambda c: norm.cdf(2*c,3,5)-norm.cdf(-3*c,3,5)-0.6 6 | print("c=",fsolve(f,0)) 7 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_10.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | a=np.loadtxt("Pdata4_6_2.txt") 5 | h=a[:,::2]; w=a[:,1::2] 6 | h=np.reshape(h,(-1,1)); w=np.reshape(w,(-1,1)) 7 | hw=np.hstack((h,w)); plt.rc('font',size=16) 8 | plt.rc('font',family='SimHei') 9 | plt.boxplot(hw,labels=['身高','体重']) 10 | plt.savefig("figure4_10.png",dpi=500); plt.show() 11 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_11.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | a=np.loadtxt("Pdata4_6_2.txt") 5 | w=a[:,1::2]; w=np.reshape(w,(-1,1)); plt.rc('font',size=16) 6 | h=plt.hist(w,20,density=True, histtype='step', cumulative=True) 7 | print(h); plt.grid() 8 | plt.savefig("figure4_11.png",dpi=500); plt.show() 9 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_12.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.stats import norm, probplot 5 | a=np.loadtxt("Pdata4_6_2.txt") 6 | h=a[:,::2]; h=h.flatten() 7 | mu=np.mean(h); s=np.std(h); print([mu,s]) 8 | sh=np.sort(h) #按从小到大排序 9 | n=len(sh); xi=(np.arange(1,n+1)-1/2)/n 10 | yi=norm.ppf(xi,mu,s) 11 | plt.rc('font',size=16);plt.rc('font',family='SimHei') 12 | plt.rc('axes',unicode_minus=False) #用来正常显示负号 13 | plt.subplot(121); plt.plot(yi, sh, 'o', label='QQ图'); 14 | plt.plot([155,185],[155,185],'r-',label='参照直线') 15 | plt.legend(); plt.subplot(122) 16 | res = probplot(h,plot=plt) 17 | plt.savefig("figure4_12.png",dpi=500); plt.show() 18 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_13.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.stats import norm 5 | a=np.loadtxt("Pdata4_6_2.txt") 6 | h=a[:,::2]; h=h.flatten() 7 | mu=np.mean(h); s=np.std(h); 8 | print("样本均值和标准差为：",[mu,s]) 9 | print("极大似然估计值为：", norm.fit(h)) 10 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_14_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_14_1.py 2 | from numpy import array, sqrt 3 | from scipy.stats import t 4 | a=array([506, 508, 499, 503, 504, 510, 497, 512, 5 | 514, 505, 493, 496, 506, 502, 509, 496]) 6 | # ddof取值为1时，标准偏差除的是(N-1)；NumPy中的std计算默认是除以N 7 | mu=a.mean(); s=a.std(ddof=1) #计算均值和标准差 8 | print(mu, s); alpha=0.05; n=len(a) 9 | val=(mu-s/sqrt(n)*t.ppf(1-alpha/2,n-1),mu+s/sqrt(n)*t.ppf(1-alpha/2,n-1)) 10 | print("置信区间为：",val) 11 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_14_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_14_2.py 2 | import numpy as np 3 | import scipy.stats as ss 4 | from scipy import stats 5 | a=np.array([506, 508, 499, 503, 504, 510, 497, 512, 6 | 514, 505, 493, 496, 506, 502, 509, 496]) 7 | alpha=0.95; df=len(a)-1 8 | ci=ss.t.interval(alpha,df,loc=a.mean(),scale=ss.sem(a)) 9 | print("置信区间为：",ci) 10 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_14_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_14_3.py 2 | import numpy as np 3 | from statsmodels.stats.weightstats import zconfint 4 | from scipy import stats 5 | a=np.array([506, 508, 499, 503, 504, 510, 497, 512, 6 | 514, 505, 493, 496, 506, 502, 509, 496]) 7 | ci=zconfint(a) 8 | print("置信区间为：",ci) 9 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_15.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_15.py 2 | import numpy as np 3 | from statsmodels.stats.weightstats import ztest 4 | sigma=0.015 5 | a=np.array([0.497, 0.506, 0.518, 0.524, 0.498, 0.511, 0.520, 0.515, 0.512]) 6 | tstat1, pvalue=ztest(a,value=0.5) #计算T统计量的观测值及p值 7 | tstat2=tstat1*a.std(ddof=1)/sigma #转换为Z统计量的观测值 8 | print('t值为：',round(tstat1,4)) 9 | print('z值为：',round(tstat2,4)); print('p值为:',round(pvalue,4)) 10 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_16.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_16.py 2 | import numpy as np 3 | from statsmodels.stats.weightstats import ztest 4 | a=np.array([3.25, 3.27, 3.24, 3.26, 3.24]) 5 | tstat, pvalue=ztest(a,value=3.25) 6 | print('检验统计量为：',tstat); print('p值为:',pvalue) 7 | 8 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_17.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_17.py 2 | import numpy as np 3 | from statsmodels.stats.weightstats import ztest 4 | a=np.array([16, 25, 21, 20, 23, 21, 19, 15, 13, 5 | 23, 17, 20, 29, 18, 22, 16, 22]) 6 | tstat, pvalue=ztest(a,value=21, alternative='smaller') 7 | print('检验统计量为：',tstat); print('p值为:',pvalue) 8 | 9 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_18.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_18.py 2 | import numpy as np 3 | from statsmodels.stats.weightstats import ttest_ind 4 | a=np.array([0.225, 0.262, 0.217, 0.240, 0.230, 0.229, 0.235, 0.217]) 5 | b=np.array([0.209, 0.205, 0.196, 0.210, 0.202, 0.207, 6 | 0.224, 0.223, 0.220, 0.201]) 7 | tstat, pvalue, df=ttest_ind(a, b, value=0) 8 | print('检验统计量为：',tstat); print('p值为:',pvalue) 9 | print('自由度为：',df) 10 | 11 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_19.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_19.py 2 | import numpy as np 3 | import scipy.stats as ss 4 | bins=np.arange(1,8) 5 | mi=np.array([36, 23, 29, 31, 34, 60, 25]) 6 | n=mi.sum(); p=np.ones(7)/7 7 | cha=(mi-n*p)**2/(n*p); st=cha.sum() 8 | bd=ss.chi2.ppf(0.95,len(bins)-1) #计算上alpha分位数 9 | print("统计量为：{}，临界值为：{}".format(st,bd)) 10 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_2.py 2 | from scipy.stats import norm 3 | from pylab import plot,fill_between,show,text,savefig,rc 4 | from numpy import array, linspace, zeros 5 | alpha=array([0.001, 0.005, 0.01, 0.025, 0.05, 0.10]) 6 | za=norm.ppf(1-alpha,0,1) #求上alpha分位数 7 | print("上alpha分位数分别为", za) 8 | x=linspace(-4, 4, 100); y=norm.pdf(x, 0, 1) 9 | rc('font',size=16); rc('text',usetex=True) 10 | plot(x,y) #画标准正态分布密度曲线 11 | x2=linspace(za[-1],4,100); y2=norm.pdf(x2); 12 | y1=[0]*len(x2) 13 | fill_between(x2, y1, y2, color='r') #y1,y2对应的点之间填充 14 | plot([-4,4],[0,0]) #画水平线 15 | text(1.9, 0.07, "$\\leftarrow\\alpha$=0.1") #标注 16 | savefig("figure4_2.png", dpi=500); show() 17 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_20.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_20.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | import scipy.stats as ss 5 | n=50; k=8 #初始小区间划分的个数 6 | a=np.loadtxt("Pdata4_20.txt") 7 | a=a.flatten(); mu=a.mean(); s=a.std() 8 | print("均值为：", mu); print("标准差为：", s) 9 | print("最大值为：",a.max()); print("最小值为：",a.min()) 10 | bins=np.array([14.2, 14.625, 14.8375, 15.05, 15.2625, 15.475, 15.9]) 11 | h=plt.hist(a,bins) 12 | f=h[0]; x=h[1] #提取各个小区间的频数和小区间端点的取值 13 | print("各区间的频数为：",f,"\n小区间端点值为：",x) 14 | p=ss.norm.cdf(x, mu, s) #计算各个分点分布函数的取值 15 | dp=np.diff(p) #计算各小区间取值的理论概率 16 | dp[0]=ss.norm.cdf(x[1],mu,s) #修改第一个区间的概率值 17 | dp[-1]=1-ss.norm.cdf(x[-2],mu,s) #修改最后一个区间的概率值 18 | print("各小区取值的理论概率为：",dp) 19 | st=sum(f**2/(n*dp))-n #计算卡方统计量的值 20 | bd=ss.chi2.ppf(0.95,k-5) #计算上alpha分位数 21 | print("统计量为：{}，临界值为：{}".format(st,bd)) 22 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_21.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_21.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | import scipy.stats as ss 5 | a=np.loadtxt("Pdata4_6_2.txt") 6 | w=a[:,1::2]; w=w.flatten() 7 | mu=w.mean(); s=w.std(ddof=1) #计算样本均值和标准差 8 | print("均值和标准差分别为：", (mu, s)) 9 | statVal, pVal=ss.kstest(w,'norm',(mu,s)) 10 | print("统计量和P值分别为：", [statVal, pVal]) 11 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_22.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_22.py 2 | import numpy as np 3 | import statsmodels.api as sm 4 | y=np.array([1620, 1670, 1700, 1750, 1800, 1580, 1600, 1640, 1720, 5 | 1460, 1540, 1620, 1680, 1500, 1550, 1610]) 6 | x=np.hstack([np.ones(5), np.full(4,2), np.full(4,3), np.full(3,4)]) 7 | d= {'x':x,'y':y} #构造字典 8 | model = sm.formula.ols("y~C(x)",d).fit() #构建模型 9 | anovat = sm.stats.anova_lm(model) #进行单因素方差分析 10 | print(anovat) 11 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_23.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_23.py 2 | import numpy as np 3 | import pandas as pd 4 | import statsmodels.api as sm 5 | df = pd.read_excel("Pdata4_23.xlsx", header=None) 6 | a=df.values.T.flatten() 7 | b=np.arange(1,6) 8 | x=np.tile(b,(4,1)).T.flatten() 9 | d={'x':x,'y':a} #构造求解需要的字典 10 | model = sm.formula.ols("y~C(x)",d).fit() #构建模型 11 | anovat = sm.stats.anova_lm(model) #进行单因素方差分析 12 | print(anovat) 13 | 14 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_24.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_24.py 2 | import numpy as np 3 | import statsmodels.api as sm 4 | y=np.array([[11, 11, 13, 10], [10, 11, 9, 12], 5 | [9, 10, 7, 6], [7, 8, 11, 10], 6 | [5, 13, 12, 14], [11, 14, 13, 10]]).flatten() 7 | A=np.tile(np.arange(1,5),(6,1)).flatten() 8 | B=np.tile(np.arange(1,4).reshape(3,1),(1,8)).flatten() 9 | d={'x1':A,'x2':B,'y':y} 10 | model = sm.formula.ols("y~C(x1)+C(x2)+C(x1):C(x2)",d).fit() #注意交互作用公式的写法 11 | anovat = sm.stats.anova_lm(model) #进行双因素方差分析 12 | print(anovat) 13 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_25_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_25_1.py 2 | import matplotlib.pyplot as plt 3 | import numpy as np 4 | x=[2.5, 3.9, 2.9, 2.4, 2.9, 0.8, 9.1, 0.8, 0.7,7.9, 1.8, 1.9, 0.8, 6.5, 1.6, 5.8, 1.3, 1.2, 2.7] 5 | y=[211, 167, 131, 191, 220, 297, 71, 211, 300, 107, 6 | 167, 266, 277, 86, 207, 115, 285, 199, 172] 7 | plt.plot(x,y,'+k', label="原始数据点") 8 | p=np.polyfit(x,y,deg=1) #拟合一次多项式 9 | print("拟合的多项式为:{}*x+{}".format(p[0],p[1])) 10 | plt.rc('font',size=16); plt.rc('font',family='SimHei') 11 | plt.plot(x, np.polyval(p,x), label="拟合的直线") 12 | print("预测值为：", np.polyval(p, 8)); plt.legend() 13 | plt.savefig("figure4_25.png", dpi=500); plt.show() 14 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_25_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_25_2.py 2 | import statsmodels.api as sm 3 | x=[2.5, 3.9, 2.9, 2.4, 2.9, 0.8, 9.1, 0.8, 0.7,7.9, 4 | 1.8, 1.9, 0.8, 6.5, 1.6, 5.8, 1.3, 1.2, 2.7] 5 | y=[211, 167, 131, 191, 220, 297, 71, 211, 300, 107, 6 | 167, 266, 277, 86, 207, 115, 285, 199, 172] 7 | df={'x':x,'y':y} 8 | res=sm.formula.ols('y~x',data=df).fit() 9 | print(res.summary(),'\n') 10 | ypred=res.predict(dict(x=8)) 11 | print('所求的预测值为:',list(ypred)) 12 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_25_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_25_3.py 2 | import statsmodels.api as sm 3 | import numpy as np 4 | x=np.array([2.5, 3.9, 2.9, 2.4, 2.9, 0.8, 9.1, 0.8, 0.7, 5 | 7.9, 1.8, 1.9, 0.8, 6.5, 1.6, 5.8, 1.3, 1.2, 2.7]) 6 | y=np.array([211, 167, 131, 191, 220, 297, 71, 211, 300, 7 | 107, 167, 266, 277, 86, 207, 115, 285, 199, 172]) 8 | X=sm.add_constant(x) 9 | md=sm.OLS(y,X).fit() #构建并拟合模型 10 | print(md.params,'\n--------\n') #提取回归系数 11 | print(md.summary2()) 12 | ypred=md.predict([1,8]) #第一列必须加1 13 | print("预测值为：",ypred) 14 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_26.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_26.py 2 | import pandas as pd 3 | a=pd.read_excel("Pdata4_26_1.xlsx") 4 | print("是否存在重复观测：",any(a.duplicated())) #输出：True 5 | a.drop_duplicates(inplace=True) #inplace=True时，直接删除a中的重复数据 6 | f=pd.ExcelWriter('Pdata4_26_2.xlsx') #创建文件对象 7 | a.to_excel(f) #把a写入新Excel文件中 8 | f.save() #保存文件，数据才真正写入Excel文件 9 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_27.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_27.py 2 | from numpy import NaN 3 | from pandas import Series 4 | data=Series([10.0, None, 20, NaN, 30]) 5 | print(data.isnull()) #输出每个元素的检测结果 6 | print("是否存在缺失值：", any(data.isnull())) #输出：True 7 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_28.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_28.py 2 | from pandas import read_excel 3 | a=read_excel("Pdata2_33.xlsx",usecols=range(1,4)) 4 | b1=a.dropna() #删除所有的缺失值 5 | b2=a.dropna(axis=1, thresh=9) #删除有效数据个数小于9的列 6 | b3=a.drop('用户B', axis=1) #删除用户B的数据 7 | print(b1,'\n---------------\n',b2,'\n---------------\n',b3) 8 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_29.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_29.py 2 | from pandas import read_excel 3 | a=read_excel("Pdata4_29.xlsx") 4 | b1=a.fillna(0) #用0填补所有的缺失值 5 | b2=a.fillna(method='ffill') #用前一行的值填补缺失值 6 | b3=a.fillna(method='bfill') #用后一行的值填补，最后一行缺失值不处理 7 | b4=a.fillna(value={'gender':a.gender.mode()[0], #性别使用众数替换 8 | 'age':a.age.mean(), #年龄使用均值替换 9 | 'income':a.income.median()}) #收入使用中位数替换 10 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_3.py 2 | from scipy.stats import binom 3 | n, p=20, 0.8 4 | print("期望和方差分布为：", binom.stats(n,p)) 5 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_30.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_30.py 2 | from pandas import read_excel 3 | import numpy as np 4 | a=read_excel("Pdata4_29.xlsx") 5 | b=a.fillna(value={'gender':a.gender.mode()[0], #性别使用众数替换 6 | 'age':a.age.interpolate(method='polynomial', order=2), 7 | #年龄使用二次多项式插值替换 8 | 'income':a.income.interpolate()}) #收入使用线性插值替换 9 | 10 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_4.py 2 | from scipy.stats import binom 3 | n, p=20, 0.8 4 | mean, variance, skewness, kurtosis=binom.stats(n, p, moments='mvsk') 5 | #上述语句不显示，只为了说明数据顺序 6 | print("所求的数字特征为：", binom.stats(n, p, moments='mvsk')) 7 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_5.py 2 | from scipy.integrate import quad 3 | from numpy import exp, sqrt, pi, abs 4 | a=80; b=0.02; BD=a/b; mu=4000; s=100 5 | y=lambda x: x*exp(-(x-mu)**2/(2*s**2))/sqrt(2*pi)/s #定义积分的被积函数 6 | I=0; x1=0; x2=10000 7 | while abs(I-BD)>1E-16: 8 | c=(x1+x2)/2 9 | I=quad(y,-10000,c)[0] #由3sigma准则这里积分下限取为-10000,取零效果一样 10 | if I>BD: x2=c 11 | else: x1=c 12 | print("最佳更换周期为：", c) 13 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_6.py 2 | from numpy import reshape, hstack, mean, median, ptp, var, std, cov, corrcoef 3 | import pandas as pd 4 | df = pd.read_excel("Pdata4_6_1.xlsx",header=None) 5 | a=df.values #提取数据矩阵 6 | h=a[:,::2] #提取奇数列身高 7 | w=a[:,1::2] #提取偶数列体重 8 | h=reshape(h,(-1, 1)) #转换成列向量，自动计算行数 9 | w=reshape(w,(-1, 1)) #转换成列向量，自动计算行数 10 | hw=hstack([h,w]) #构造两列的数组 11 | print([mean(h),median(h),ptp(h),var(h),std(h)]) #计算均值,中位数,极差,方差,标准差 12 | print("协方差为：{}\n相关系数为：{}".format(cov(hw.T)[0,1],corrcoef(hw.T)[0,1])) 13 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_7.py 2 | from numpy import reshape, c_ 3 | import pandas as pd 4 | df = pd.read_excel("Pdata4_6_1.xlsx",header=None) 5 | a=df.values; h1=a[:,::2]; w1=a[:,1::2] 6 | h2=reshape(h1,(-1, 1)); w2=reshape(w1,(-1, 1)) 7 | df2=pd.DataFrame(c_[h2,w2],columns=["身高","体重"]) #构造数据框 8 | print("求得的描述统计量如下：\n",df2.describe()) 9 | print("偏度为：\n",df2.skew()) 10 | print("峰度为：\n",df2.kurt()) 11 | print("分位数为：\n",df2.quantile(0.9)) 12 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_8.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | a=np.loadtxt("Pdata4_6_2.txt") 5 | h=a[:,::2]; w=a[:,1::2] 6 | h=np.reshape(h,(-1,1)); w=np.reshape(w,(-1,1)) 7 | plt.rc('font',size=16); plt.rc('font',family="SimHei") 8 | plt.subplot(121); plt.xlabel("身高"); plt.hist(h,10) #只画直方图不返回频数表 9 | plt.subplot(122); ps=plt.hist(w,6) #画图并返回频数表ps 10 | plt.xlabel("体重"); print("体重的频数表为：", ps) 11 | plt.savefig("figure4_8.png", dpi=500); plt.show() 12 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/Pex4_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex4_9.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | a=np.loadtxt("Pdata4_9.txt") #读入两行的数据 5 | b=a.T #转置成两列的数据 6 | plt.rc('font',size=16); plt.rc('font',family='SimHei') 7 | plt.boxplot(b,labels=['女子','男子']) 8 | plt.savefig('figure4_9.png', dpi=500); plt.show() 9 | -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4-9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4-9.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_10.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_11.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_12.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_2.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_22.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_22.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_25.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_25.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_27.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_27.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_8.png -------------------------------------------------------------------------------- /04第4章 概率论与数理统计/figure4_9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/04第4章 概率论与数理统计/figure4_9.png -------------------------------------------------------------------------------- /05第5章 线性规划/Pan5_1_1.py: -------------------------------------------------------------------------------- 1 | # 程序文件Pan5_1_1.py 2 | import matplotlib.pyplot as plt 3 | from numpy import ones, diag, c_, zeros 4 | from scipy.optimize import linprog 5 | 6 | plt.rc("text", usetex=True) 7 | plt.rc("font", size=16) 8 | c = [-0.05, -0.27, -0.19, -0.185, -0.185] 9 | A = c_[zeros(4), diag([0.025, 0.015, 0.055, 0.026])] 10 | Aeq = [[1, 1.01, 1.02, 1.045, 1.065]] 11 | beq = [1] 12 | a = 0 13 | aa = [] 14 | ss = [] 15 | while a < 0.05: 16 | b = ones(4) * a 17 | res = linprog(c, A, b, Aeq, beq) 18 | x = res.x 19 | Q = -res.fun 20 | aa.append(a) 21 | ss.append(Q) # 把最优值都保存起来 22 | a = a + 0.001 23 | plt.plot(aa, ss, "r*") 24 | plt.xlabel("$a$") 25 | plt.ylabel("$Q$", rotation=90) 26 | plt.savefig("figure5_1_1.png", dpi=500) 27 | plt.show() 28 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pan5_1_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pan5_1_2.py 2 | import pylab as plt 3 | import numpy as np 4 | import cvxpy as cp 5 | plt.rc('text',usetex=True); plt.rc('font',size=16) 6 | x=cp.Variable(6,pos=True) 7 | obj=cp.Minimize(x[5]) 8 | a1=np.array([0.025, 0.015, 0.055, 0.026]) 9 | a2=np.array([0.05, 0.27, 0.19, 0.185, 0.185]) 10 | a3=np.array([1, 1.01, 1.02, 1.045, 1.065]) 11 | k=0.05; kk=[]; ss=[] 12 | while k<0.27: 13 | con=[cp.multiply(a1,x[1:5])-x[5]<=0, 14 | a2@x[:-1]>=k, a3@x[:-1]==1] 15 | prob=cp.Problem(obj,con) 16 | prob.solve(solver='GLPK_MI') 17 | kk.append(k); ss.append(prob.value) 18 | k=k+0.005 19 | plt.plot(kk,ss,'r*') 20 | plt.xlabel('$k$'); plt.ylabel('$R$',rotation=90) 21 | plt.savefig('figure5_1_2.png',dpi=500); plt.show() 22 | 23 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pan5_1_3.py: -------------------------------------------------------------------------------- 1 | # 程序文件Pan5_1_3.py 2 | import pylab as plt 3 | import numpy as np 4 | import cvxpy as cp 5 | 6 | # plt.rc('text',usetex=True); plt.rc('font',size=16) 7 | x = cp.Variable(6, pos=True) 8 | obj = cp.Minimize(x[5]) 9 | a1 = np.array([0.025, 0.015, 0.055, 0.026]) 10 | a2 = np.array([0.05, 0.27, 0.19, 0.185, 0.185]) 11 | a3 = np.array([1, 1.01, 1.02, 1.045, 1.065]) 12 | k = 0.21 13 | kk = [] 14 | ss = [] 15 | con = [cp.multiply(a1, x[1:5]) - x[5] <= 0, a2 @ x[:-1] >= 0.21, a3 @ x[:-1] == 1] 16 | prob = cp.Problem(obj, con) 17 | prob.solve(solver="GLPK_MI") 18 | print(x.value, "\n") 19 | print(prob.value) 20 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pdata5_6.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/05第5章 线性规划/Pdata5_6.xlsx -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_1.py: -------------------------------------------------------------------------------- 1 | # 程序文件Pex5_1.py 2 | from scipy.optimize import linprog 3 | 4 | c = [-1, 4] 5 | A = [[-3, 1], [1, 2]] 6 | b = [6, 4] 7 | bound = ((None, None), (-3, None)) 8 | res = linprog(c, A, b, None, None, bound) 9 | print("目标函数的最小值：", res.fun) 10 | print("最优解为：", res.x) 11 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_2_1.py: -------------------------------------------------------------------------------- 1 | from scipy.optimize import linprog 2 | c=[-1, 2, 3]; A = [[-2, 1, 1], [3, -1, -2]] 3 | b=[[9], [-4]]; Aeq=[[4, -2, -1]]; beq=[-6] 4 | LB=[-10, 0, None]; 5 | UB=[None]*len(c) #生成3个None的列表 6 | bound=tuple(zip(LB, UB)) #生成决策向量界限的元组 7 | res=linprog(c,A,b,Aeq,beq,bound) 8 | print("目标函数的最小值：",res.fun) 9 | print("最优解为：",res.x) 10 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_2_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_2_2.py 2 | from scipy.optimize import linprog 3 | import numpy as np 4 | c=np.array([1, -2, -3]) #为了下面取相反数，这里使用数组 5 | A =[[-2, 1, 1], [3, -1, -2]] 6 | b=[[9], [-4]]; Aeq=[[4, -2, -1]]; beq=[-6] 7 | LB=[-10, 0, None]; 8 | UB=[None]*len(c) #生成3个None的列表 9 | bound=tuple(zip(LB, UB)) #生成决策向量界限的元组 10 | res=linprog(-c,A,b,Aeq,beq,bound) 11 | print("目标函数的最小值：",res.fun) 12 | print("最优解为：",res.x) 13 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_3.py 2 | from scipy.optimize import linprog 3 | c=[110, 120, 130, 110, 115,-150] #目标向量 4 | A =[[1,1,0,0,0, 0],[0,0,1,1,1,0],[8.8,6.1,2.0,4.2,5.0,-6],[-8.8,-6.1,-2.0,-4.2,-5.0,3]] 5 | b=[[200],[250],[0],[0]]; Aeq=[[1,1,1,1,1,-1]]; beq=[0] 6 | res=linprog(c,A,b,Aeq,beq) 7 | print("目标函数的最小值：",res.fun) 8 | print("最优解为：",res.x) 9 | 10 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_4.py 2 | import numpy as np 3 | from cvxopt import matrix, solvers 4 | c=matrix([-4.,-5]); A=matrix([[2.,1],[1,2],[-1,0],[0,-1]]).T 5 | b=matrix([3.,3,0,0]); sol=solvers.lp(c,A,b) 6 | print("最优解为：\n",sol['x']) 7 | print("最优值为：",sol['primal objective']) 8 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_5.py 2 | import numpy 3 | from cvxopt import matrix, solvers 4 | c=matrix([2.,1]); A=matrix([[-1.,1],[-1,-1],[1,-2],[0,-1]]).T 5 | b=matrix([1.,-2,4,0]); Aeq=matrix([1.,2],(1,2)) #Aeq为行向量 6 | beq=matrix(3.5); sol=solvers.lp(c,A,b,Aeq,beq) 7 | print("最优解为：\n",sol['x']) 8 | print("最优值为：",sol['primal objective']) 9 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_6.py 2 | import cvxpy as cp 3 | import numpy as np 4 | import pandas as pd 5 | d1=pd.read_excel("Pdata5_6.xlsx",header=None) 6 | d2=d1.values; c=d2[:-1,:-1] 7 | d=d2[-1,:-1].reshape(1,-1); e=d2[:-1,-1].reshape(-1,1) 8 | x=cp.Variable((6,8)) 9 | obj=cp.Minimize(cp.sum(cp.multiply(c,x))) #构造目标函数 10 | con=[cp.sum(x,axis=1,keepdims=True)<=e, 11 | cp.sum(x,axis=0,keepdims=True)==d,x>=0] #构造约束条件 12 | prob=cp.Problem(obj,con) #构造模型 13 | prob.solve(solver='GLPK_MI',verbose =True) #求解模型 14 | print("最优值为：",prob.value) 15 | print("最优解为：\n",x.value) 16 | 17 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_7.py 2 | from scipy.optimize import linprog 3 | c=[-72, -64] #目标向量 4 | A =[[1, 1],[12, 8]]; b=[[50],[480]] 5 | bound=((0,100/3.0),(0,None)) 6 | res=linprog(c,A,b,None,None,bound,method='simplex',options={"disp": True}) 7 | print("求解结果如下：",res) 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /05第5章 线性规划/Pex5_7_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex5_7_2.py 2 | from scipy.optimize import linprog 3 | c=[-90, -64] #目标向量 4 | A =[[1, 1],[12, 8]]; b=[[50],[480]] 5 | bound=((0,100/3.0),(0,None)) 6 | res=linprog(c,A,b,None,None,bound,method='simplex',options={"disp": True}) 7 | print("求解结果如下：",res) 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /05第5章 线性规划/figure5_1_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/05第5章 线性规划/figure5_1_1.png -------------------------------------------------------------------------------- /05第5章 线性规划/figure5_1_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/05第5章 线性规划/figure5_1_2.png -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pan6_1.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/06第6章 整数规划与非线性规划/Pan6_1.xlsx -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pan6_1_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pan6_1_1.py 2 | import numpy as np 3 | import pandas as pd 4 | x0=np.array([150, 85, 150, 145, 130, 0]) 5 | y0=np.array([140, 85, 155, 50, 150, 0]) 6 | q=np.array([243, 236, 220.5, 159, 230, 52]) 7 | d=np.zeros((6,6)); a0=np.zeros((6,6)); b0=np.zeros((6,6)) 8 | xy0=np.c_[x0,y0] 9 | for i in range(6): 10 | for j in range(6): d[i,j]=np.linalg.norm(xy0[i]-xy0[j]) 11 | d[np.where(d==0)]=np.inf 12 | a0=np.arcsin(8./d)*180/np.pi 13 | xy1=x0+1j*y0; xy2=np.exp(1j*q*np.pi/180) 14 | for m in range(6): 15 | for n in range(6): 16 | if n!=m: b0[m,n]=np.angle((xy2[n]-xy2[m])/(xy1[m]-xy1[n])) 17 | b0=b0*180/np.pi 18 | f=pd.ExcelWriter('Pan6_1.xlsx') #创建文件对象 19 | pd.DataFrame(a0).to_excel(f,"sheet1",index=None) #把a0写入Excel文件 20 | pd.DataFrame(b0).to_excel(f,"sheet2",index=None) #把b0写入表单2 21 | f.save() 22 | 23 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pan6_1_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pan6_1_2.py 2 | import numpy as np 3 | import pandas as pd 4 | from scipy.optimize import minimize 5 | a0=pd.read_excel("Pan6_1.xlsx") #读入第1个表单 6 | b0=pd.read_excel("Pan6_1.xlsx",1) #读入第2个表单 7 | a0=a0.values; b0=b0.values #提取数值 8 | obj=lambda x: np.sum(np.abs(x)) 9 | bd=[(-30,30) for i in range(6)] #决策向量的界限 10 | x0=np.ones((1,6)) 11 | cons=[] 12 | for i in range(5): 13 | for j in range(i+1,6): 14 | cons.append({'type': 'ineq', 'fun': lambda x: np.abs(b0[i,j]+(x[i]+x[j])/2)-a0[i,j]}) 15 | res = minimize(obj, np.ones((1, 6)), constraints=cons, bounds=bd) 16 | print(res) 17 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_1.py 2 | import cvxpy as cp 3 | from numpy import array 4 | c=array([40,90]) #定义目标向量 5 | a=array([[9,7],[-7,-20]]) #定义约束矩阵 6 | b=array([56,-70]) #定义约束条件的右边向量 7 | x=cp.Variable(2,integer=True) #定义两个整数决策变量 8 | obj=cp.Minimize(c*x) #构造目标函数 9 | cons=[a*x<=b, x>=0] #构造约束条件 10 | prob=cp.Problem(obj, cons) #构建问题模型 11 | prob.solve(solver='GLPK_MI',verbose =True) #求解问题 12 | print("最优值为:",prob.value) 13 | print("最优解为：\n",x.value) 14 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_2.py 2 | import cvxpy as cp 3 | import numpy as np 4 | c=np.array([[4, 8, 7, 15, 12], 5 | [7, 9, 17, 14, 10], 6 | [6, 9, 12, 8, 7], 7 | [6, 7, 14, 6, 10], 8 | [6, 9, 12, 10, 6]]) 9 | x = cp.Variable((5,5),integer=True) 10 | obj = cp.Minimize(cp.sum(cp.multiply(c,x))) 11 | con= [0 <= x, x <= 1, cp.sum(x, axis=0, keepdims=True)==1, 12 | cp.sum(x, axis=1, keepdims=True)==1] 13 | prob = cp.Problem(obj, con) 14 | prob.solve(solver='GLPK_MI') 15 | print("最优值为:",prob.value) 16 | print("最优解为：\n",x.value) 17 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_3_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_3_1.py 2 | import cvxpy as cp 3 | import numpy as np 4 | L=np.array([48.7,52.0,61.3,72.0,48.7,52.0,64.0]) 5 | w=np.array([2000,3000,1000,500,4000,2000,1000]) 6 | a=np.array([8,7,9,6,6,4,8]) 7 | x=cp.Variable((2,7), integer=True) 8 | obj=cp.Maximize(cp.sum(x*L)) 9 | con=[cp.sum(x,axis=0,keepdims=True)<=a.reshape(1,7), 10 | x*L<=1020, x*w<=40000, cp.sum(x[:,4:]*L[4:])<=302.7, x>=0] 11 | prob = cp.Problem(obj, con) 12 | prob.solve(solver='GLPK_MI',verbose =True) 13 | print("最优值为:",prob.value) 14 | print("最优解为：\n",x.value) 15 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_3_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_3_2.py 2 | import cvxpy as cp 3 | import numpy as np 4 | L=np.array([48.7,52.0,61.3,72.0,48.7,52.0,64.0]) 5 | w=np.array([2000,3000,1000,500,4000,2000,1000]) 6 | a=np.array([8,7,9,6,6,4,8]) 7 | x=cp.Variable((2,7), integer=True) 8 | obj=cp.Maximize(cp.sum(x*w)) 9 | con=[cp.sum(x,axis=0,keepdims=True)<=a.reshape(1,7), 10 | x*L<=1020, x*w<=40000, cp.sum(x[:,4:]*L[4:])<=302.7,x>=0] 11 | prob = cp.Problem(obj, con) 12 | prob.solve(solver='GLPK_MI',verbose =True) 13 | print("最优值为:",prob.value) 14 | print("最优解为：\n",x.value) 15 | 16 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_4.py 2 | from scipy.optimize import minimize 3 | from numpy import ones 4 | def obj(x): 5 | x1,x2,x3=x 6 | return (2+x1)/(1+x2)-3*x1+4*x3 7 | LB=[0.1]*3; UB=[0.9]*3 8 | bound=tuple(zip(LB, UB)) #生成决策向量界限的元组 9 | res=minimize(obj,ones(3),bounds=bound) #第2个参数为初值 10 | print(res.fun,'\n',res.success,'\n',res.x) #输出最优值、求解状态、最优解 11 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_5.py 2 | from scipy.optimize import minimize 3 | import numpy as np 4 | c1=np.array([1,1,3,4,2]); c2=np.array([-8,-2,-3,-1,-2]) 5 | A=np.array([[1,1,1,1,1],[1,2,2,1,6], 6 | [2,1,6,0,0],[0,0,1,1,5]]) 7 | b=np.array([400,800,200,200]) 8 | obj=lambda x: np.dot(-c1,x**2)+np.dot(-c2,x) 9 | cons={'type':'ineq','fun':lambda x:b-A@x} 10 | bd=[(0,99) for i in range(A.shape[1])] 11 | res=minimize(obj,np.ones(5)*90,constraints=cons,bounds=bd) 12 | print(res) #输出解的信息 13 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pan6_6.py 2 | import numpy as np 3 | from cvxopt import matrix,solvers 4 | n=3; P=matrix(0.,(n,n)) 5 | P[::n+1]=[3,2,1.7]; q=matrix([3,-8.2,-1.95]) 6 | A=matrix([[1.,0,1],[-1,2,0],[0,1,2]]).T 7 | b=matrix([2.,2,3]) 8 | Aeq=matrix(1.,(1,n)); beq=matrix(3.) 9 | s=solvers.qp(P,q,A,b,Aeq,beq) 10 | print("最优解为：",s['x']) 11 | print("最优值为：",s['primal objective']) 12 | 13 | -------------------------------------------------------------------------------- /06第6章 整数规划与非线性规划/Pex6_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex6_7.py 2 | import cvxpy as cp 3 | import numpy as np 4 | c1=np.array([1, 1, 3, 4, 2]) 5 | c2=np.array([-8, -2, -3, -1, -2]) 6 | a=np.array([[1, 1, 1, 1, 1], [1, 2, 2, 1, 6], [2, 1, 6, 0, 0], [0, 0, 1, 1, 5]]) 7 | b=np.array([400, 800, 200, 200]) 8 | x=cp.Variable(5,integer=True) 9 | obj=cp.Minimize(c1*x**2+c2*x) 10 | con=[0<=x, x<=99, a*x<=b] 11 | prob = cp.Problem(obj, con) 12 | prob.solve() 13 | print("最优值为:",prob.value) 14 | print("最优解为：\n",x.value) 15 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pex7_4.py: -------------------------------------------------------------------------------- 1 | #程序文件名Pex7_4.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.interpolate import interp1d 5 | x=np.arange(0,25,2) 6 | y=np.array([12, 9, 9, 10, 18, 24, 28, 27, 25, 20, 18, 15, 13]) 7 | xnew=np.linspace(0, 24, 500) #插值点 8 | f1=interp1d(x, y); y1=f1(xnew); 9 | f2=interp1d(x, y,'cubic'); y2=f2(xnew) 10 | plt.rc('font',size=16); plt.rc('font',family='SimHei') 11 | plt.subplot(121), plt.plot(xnew, y1); plt.xlabel("（A）分段线性插值") 12 | plt.subplot(122); plt.plot(xnew, y2); plt.xlabel("（B）三次样条插值") 13 | plt.savefig("figure7_4.png", dpi=500); plt.show() 14 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pex7_7.py: -------------------------------------------------------------------------------- 1 | #程序文件名Pex7_7.py 2 | from numpy import polyfit, polyval, array, arange 3 | from matplotlib.pyplot import plot,show,rc 4 | x0=arange(0, 1.1, 0.1) 5 | y0=array([-0.447, 1.978, 3.28, 6.16, 7.08, 7.34, 7.66, 9.56, 9.48, 9.30, 11.2]) 6 | p=polyfit(x0, y0, 2) #拟合二次多项式 7 | print("拟合二次多项式的从高次幂到低次幂系数分别为:",p) 8 | yhat=polyval(p,[0.25, 0.35]); print("预测值分别为：", yhat) 9 | rc('font',size=16) 10 | plot(x0, y0, '*', x0, polyval(p, x0), '-'); show() 11 | 12 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pex7_8.py: -------------------------------------------------------------------------------- 1 | #程序文件名Pex7_8.py 2 | import numpy as np 3 | from scipy.optimize import curve_fit 4 | y=lambda x, a, b, c: a*x**2+b*x+c 5 | x0=np.arange(0, 1.1, 0.1) 6 | y0=np.array([-0.447, 1.978, 3.28, 6.16, 7.08, 7.34, 7.66, 9.56, 9.48, 9.30, 11.2]) 7 | popt, pcov=curve_fit(y, x0, y0) 8 | print("拟合的参数值为：", popt) 9 | print("预测值分别为：", y(np.array([0.25, 0.35]), *popt)) 10 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pex7_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex7_9.py 2 | import numpy as np 3 | from scipy.optimize import curve_fit 4 | x0=np.array([6, 2, 6, 7, 4, 2, 5, 9]) 5 | y0=np.array([4, 9, 5, 3, 8, 5, 8, 2]) 6 | z0=np.array([5, 2, 1, 9, 7, 4, 3, 3]) 7 | xy0=np.vstack((x0, y0)) 8 | def Pfun(t, a, b, c): 9 | return a*np.exp(b*t[0])+c*t[1]**2 10 | popt, pcov=curve_fit(Pfun, xy0, z0) 11 | print("a，b，c的拟合值为：", popt) 12 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pfun7_1.py: -------------------------------------------------------------------------------- 1 | #程序文件名Pfun7_1.py 2 | def w(x, y, i, x0): 3 | p=1.0 4 | for j in range(len(x)): 5 | if j==i: continue 6 | p *= (x0-x[j]); p /= (x[i]-x[j]) 7 | return p 8 | 9 | def Lag_intp(x, y, x0): 10 | s=0 11 | for i in range(len(i)): s += w(x, y, i, x0) 12 | return s 13 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pfun7_2.py: -------------------------------------------------------------------------------- 1 | #程序文件名Pfun7_2.py 2 | def diff_forward(f, k, h, x): 3 | if k<=0: return f(x) 4 | else: return diff_forward(f, k-1, h, x+h) - diff_forward(f, k-1, h, x) 5 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/Pfun7_3.py: -------------------------------------------------------------------------------- 1 | #程序文件名Pfun7_3.py 2 | """计算n阶差商 f[x0, x1, x2 ... xn] 3 | 输入参数：xi为所有插值节点的数组 4 | 输入参数：fi为所有插值节点函数值的数组 5 | 返回值: 返回xi的i阶差商(i为xi长度减1)""" 6 | def diff_quo(xi=[], fi=[]): 7 | if len(xi)>2 and len(fi)>2: 8 | return (diff_quo(xi[:len(xi)-1],fi[:len(fi)-1])-diff_quo(xi[1:len(xi)],fi[1:len(fi)]))\ 9 | /float(xi[0]-xi[-1]) #续行 10 | return (fi[0]- fi[1])/float(xi[0]-xi[1]) 11 | -------------------------------------------------------------------------------- /07第7章 插值与拟合/figure7_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/07第7章 插值与拟合/figure7_10.png -------------------------------------------------------------------------------- /07第7章 插值与拟合/figure7_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/07第7章 插值与拟合/figure7_4.png -------------------------------------------------------------------------------- /07第7章 插值与拟合/figure7_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/07第7章 插值与拟合/figure7_5.png -------------------------------------------------------------------------------- /07第7章 插值与拟合/figure7_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/07第7章 插值与拟合/figure7_6.png -------------------------------------------------------------------------------- /07第7章 插值与拟合/figure7_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/07第7章 插值与拟合/figure7_7.png -------------------------------------------------------------------------------- /07第7章 插值与拟合/laglangri.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | def h(x,y,a): 3 | s=0.0 4 | for i in range(len(y)): 5 | t=y[i] 6 | for j in range(len(y)): 7 | if i !=j: 8 | t*=(a-x[j])/(x[i]-x[j]) 9 | s +=t 10 | return s 11 | 12 | x=[1,2]; y=[2,4] 13 | print(h(x,y,1.5)) 14 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pan8_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pan8_1.py 2 | import numpy as np 3 | from scipy.integrate import odeint 4 | s0=155.0; i0=1.0; s_inf=60.0; 5 | sigma=(np.log(s0)-np.log(s_inf))/(s0+i0-s_inf) 6 | print("sigma=",sigma) 7 | S=np.array([155, 153, 139, 101]) 8 | I=(s0+i0)-S+1/sigma*np.log(S/s0) 9 | print("所求的解为：\n",I) 10 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pdata8_10_1.txt: -------------------------------------------------------------------------------- 1 | 1790 1800 1810 1820 1830 1840 1850 1860 2 | 3.9 5.3 7.2 9.6 12.9 17.1 23.2 31.4 3 | 1870 1880 1890 1900 1910 1920 1930 1940 4 | 38.6 50.2 62.9 76.0 92.0 106.5 123.2 131.7 5 | 1950 1960 1970 1980 1990 2000 6 | 150.7 179.3 204.0 226.5 251.4 281.4 7 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_1.py 2 | from sympy.abc import x 3 | from sympy import diff, dsolve, simplify, Function 4 | y=Function('y') 5 | eq=diff(y(x),x,2)+2*diff(y(x),x)+2*y(x) #定义方程 6 | con={y(0): 0, diff(y(x),x).subs(x,0): 1} #定义初值条件 7 | y=dsolve(eq, ics=con) 8 | print(simplify(y)) 9 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_10_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_10_1.py 2 | import numpy as np 3 | from scipy.optimize import curve_fit 4 | a=[]; b=[]; 5 | with open("Pdata8_10_1.txt") as f: #打开文件并绑定对象f 6 | s=f.read().splitlines() #返回每一行的数据 7 | for i in range(0, len(s),2): #读入奇数行数据 8 | d1=s[i].split("\t") 9 | for j in range(len(d1)): 10 | if d1[j]!="": a.append(eval(d1[j])) #把非空的字符串转换为年代数据 11 | for i in range(1, len(s), 2): #读入偶数行数据 12 | d2=s[i].split("\t") 13 | for j in range(len(d2)): 14 | if d2[j] != "": b.append(eval(d2[j])) #把非空的字符串转换为人口数据 15 | c=np.vstack((a,b)) #构造两行的数组 16 | np.savetxt("Pdata8_10_2.txt", c) #把数据保存起来供下面使用 17 | x=lambda t, r, xm: xm/(1+(xm/3.9-1)*np.exp(-r*(t-1790))) 18 | bd=((0, 200), (0.1,1000)) #约束两个参数的下界和上界 19 | popt, pcov=curve_fit(x, a[1:], b[1:], bounds=bd) 20 | print(popt); print("2010年的预测值为：", x(2010, *popt)) 21 | 22 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_10_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_10_2.py 2 | import numpy as np 3 | d=np.loadtxt("Pdata8_10_2.txt") #加载文件中的数据 4 | t0=d[0]; x0=d[1] #提取年代数据及对应的人口数据 5 | b=np.diff(x0)/10/x0[:-1] #构造线性方程组的常数项列 6 | a=np.vstack([np.ones(len(x0)-1),-x0[:-1]]).T #构造线性方程组系数矩阵 7 | rs=np.linalg.pinv(a)@b; r=rs[0]; xm=r/rs[1] 8 | print("人口增长率r和人口最大值xm的拟合值分别为", np.round([r,xm],4)) 9 | xhat=xm/(1+(xm/3.9-1)*np.exp(-r*(2010-1790))) #求预测值 10 | print("2010年的预测值为：",round(xhat,4)) 11 | 12 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_11.py 2 | import sympy as sp 3 | sp.var('t',positive=True); sp.var('s') #定义符号变量 4 | sp.var('Y',cls=sp.Function) #定义符号函数 5 | g=4*t*sp.exp(t) 6 | Lg=sp.laplace_transform(g,t,s) #方程右端项的拉氏变换 7 | d=s**4*Y(s)+2*s**2*Y(s)+Y(s) 8 | de=d-Lg[0] #定义取拉氏变换后的代数方程 9 | Ys=sp.solve(de,Y(s))[0] #求像函数 10 | Ys=sp.factor(Ys) 11 | yt=sp.inverse_laplace_transform(Ys,s,t) 12 | print("y(t)=",yt); yt=yt.rewrite(sp.exp) 13 | #这里的变换只是为了把解化成指数函数，并且不出现虚数 14 | yt=yt.as_real_imag(); print("y(t)=",yt) 15 | yt=sp.simplify(yt[0]); print("y(t)=",yt) 16 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_12.py 2 | import sympy as sp 3 | import pylab as plt 4 | import numpy as np 5 | sp.var('t',positive=True); sp.var('s') #定义符号变量 6 | sp.var('X,Y',cls=sp.Function) #定义符号函数 7 | g=40*sp.sin(3*t) 8 | Lg=sp.laplace_transform(g,t,s) 9 | eq1=2*s**2*X(s)+6*X(s)-2*Y(s) 10 | eq2=s**2*Y(s)-2*X(s)+2*Y(s)-Lg[0] 11 | eq=[eq1,eq2] #定义取拉氏变换后的代数方程组 12 | XYs=sp.solve(eq,(X(s),Y(s))) #求像函数 13 | Xs=XYs[X(s)]; Ys=XYs[Y(s)] 14 | Xs=sp.factor(Xs); Ys=sp.factor(Ys) 15 | xt=sp.inverse_laplace_transform(Xs,s,t) 16 | yt=sp.inverse_laplace_transform(Ys,s,t) 17 | print("x(t)=",xt); print("y(t)=",yt) 18 | fx=sp.lambdify(t,xt,'numpy') #转换为匿名函数 19 | fy=sp.lambdify(t,yt,'numpy') 20 | t=np.linspace(-5,5,100) 21 | plt.rc('text',usetex=True) 22 | plt.plot(t,fx(t),'*-k',label='$x(t)$') 23 | plt.plot(t,fy(t),'.-r',label='$y(t)$') 24 | plt.xlabel('$t$'); plt.legend(); plt.show() 25 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_2.py 2 | from sympy.abc import x #引进符号变量x 3 | from sympy import Function, diff, dsolve, sin 4 | y=Function('y') 5 | eq=diff(y(x),x,2)+2*diff(y(x),x)+2*y(x)-sin(x) #定义方程 6 | con={y(0): 0, diff(y(x), x).subs(x,0): 1} #定义初值条件 7 | y=dsolve(eq, ics=con) 8 | print(y) 9 | 10 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_3_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_3_1.py 2 | import sympy as sp 3 | t=sp.symbols('t') 4 | x1,x2,x3=sp.symbols('x1,x2,x3',cls=sp.Function) 5 | eq=[x1(t).diff(t)-2*x1(t)+3*x2(t)-3*x3(t), 6 | x2(t).diff(t)-4*x1(t)+5*x2(t)-3*x3(t), 7 | x3(t).diff(t)-4*x1(t)+4*x2(t)-2*x3(t)] 8 | con={x1(0):1, x2(0):2, x3(0):3} 9 | s=sp.dsolve(eq, ics=con); print(s) 10 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_3_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_3_2.py 2 | import sympy as sp 3 | t=sp.symbols('t') 4 | x1,x2,x3=sp.symbols('x1:4',cls=sp.Function) 5 | x=sp.Matrix([x1(t),x2(t),x3(t)]) 6 | A=sp.Matrix([[2,-3,3],[4,-5,3],[4,-4,2]]) 7 | eq=x.diff(t)-A*x 8 | s=sp.dsolve(eq,ics={x1(0):1,x2(0):2,x3(0):3}) 9 | print(s) 10 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_4.py 2 | from scipy.integrate import odeint 3 | from numpy import arange 4 | dy=lambda y, x: -2*y+x**2+2*x 5 | x=arange(1, 10.5, 0.5) 6 | sol=odeint(dy, 2, x) 7 | print("x={}\n对应的数值解y={}".format(x, sol.T)) 8 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_5.py 2 | from scipy.integrate import odeint 3 | from sympy.abc import t 4 | import numpy as np 5 | import matplotlib.pyplot as plt 6 | def Pfun(y,x): 7 | y1, y2=y; 8 | return np.array([y2, -2*y1-2*y2]) 9 | x=np.arange(0, 10, 0.1) #创建时间点 10 | sol1=odeint(Pfun, [0.0, 1.0], x) #求数值解 11 | plt.rc('font',size=16); plt.rc('font',family='SimHei') 12 | plt.plot(x, sol1[:,0],'r*',label="数值解") 13 | plt.plot(x, np.exp(-x)*np.sin(x), 'g', label="符号解曲线") 14 | plt.legend(); plt.savefig("figure8_5.png"); plt.show() 15 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_7.py 2 | import sympy as sp 3 | sp.var('t, k') #定义符号变量t,k 4 | u = sp.var('u', cls=sp.Function) #定义符号函数 5 | eq = sp.diff(u(t), t) + k * (u(t) - 24) #定义方程 6 | uu = sp.dsolve(eq, ics={u(0): 150}) #求微分方程的符号解 7 | print(uu) 8 | kk = sp.solve(uu, k) #kk返回值是列表，可能有多个解 9 | k0 = kk[0].subs({t: 10.0, u(t): 100.0}) 10 | print(kk, '\t', k0) 11 | u1 = uu.args[1] #提出符号表达式 12 | u0 = u1.subs({t: 20, k: k0}) #代入具体值 13 | print("20分钟后的温度为：", u0) 14 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_8.py 2 | import sympy as sp 3 | sp.var('h') #定义符号变量 4 | sp.var('t', cls=sp.Function) #定义符号函数 5 | g = 9.8 6 | eq = t(h).diff(h) -10000*sp.pi/0.62/sp.sqrt(2*g)*(h**(3/2)-2*h**(1/2)) #定义方程 7 | t = sp.dsolve(eq, ics={t(1): 0}) #求微分方程的符号解 8 | t = sp.simplify(t) 9 | print(t.args[1].n(9)) 10 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/Pex8_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex8_9.py 2 | from numpy import array 3 | v0=array([45, 65, 80]) 4 | T0=1; L=4.5; I=9; mu=0.7; g=9.8 5 | T=v0/(2*mu*g)+(I+L)/v0+T0 6 | print(T) 7 | 8 | -------------------------------------------------------------------------------- /08第8章 微分方程模型/figure8_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/08第8章 微分方程模型/figure8_5.png -------------------------------------------------------------------------------- /08第8章 微分方程模型/figure8_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/08第8章 微分方程模型/figure8_6.png -------------------------------------------------------------------------------- /09第9章 综合评价方法/Pdata9_1_1.txt: -------------------------------------------------------------------------------- 1 | 2.0 1500 20000 5500000 0.5 1 2 | 2.5 2700 18000 6500000 0.3 0.5 3 | 1.8 2000 21000 4500000 0.7 0.7 4 | 2.2 1800 20000 5000000 0.5 0.5 5 | -------------------------------------------------------------------------------- /09第9章 综合评价方法/Pdata9_1_2.txt: -------------------------------------------------------------------------------- 1 | 4.671418358670517135e-01 3.661805568819554435e-01 5.055601391655586418e-01 4.931467546574994643e-01 4.811252243246880722e-01 7.088812050083358463e-01 2 | 5.839272948338146696e-01 6.591250023875198094e-01 4.550041252490027999e-01 4.009916191406812658e-01 2.886751345948128655e-01 3.544406025041679231e-01 3 | 4.204276522803465643e-01 4.882407425092739617e-01 5.308381461238366184e-01 5.853018901743177738e-01 6.735753140545632789e-01 4.962168435058350591e-01 4 | 5.138560194537569181e-01 4.394166682583465766e-01 5.055601391655586418e-01 5.392243224159085635e-01 4.811252243246880722e-01 3.544406025041679231e-01 5 | -------------------------------------------------------------------------------- /09第9章 综合评价方法/Pdata9_1_3.txt: -------------------------------------------------------------------------------- 1 | 7.999999999999999334e-01 5.555555555555555802e-01 9.523809523809523281e-01 8.181818181818182323e-01 7.142857142857143016e-01 1.000000000000000000e+00 2 | 1.000000000000000000e+00 1.000000000000000000e+00 8.571428571428570953e-01 6.923076923076922906e-01 4.285714285714286031e-01 5.000000000000000000e-01 3 | 7.199999999999999734e-01 7.407407407407408106e-01 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 6.999999999999999556e-01 4 | 8.800000000000000044e-01 6.666666666666667407e-01 9.523809523809523281e-01 9.000000000000000222e-01 7.142857142857143016e-01 5.000000000000000000e-01 5 | -------------------------------------------------------------------------------- /09第9章 综合评价方法/Pdata9_1_4.txt: -------------------------------------------------------------------------------- 1 | 2.857142857142856429e-01 0.000000000000000000e+00 6.666666666666666297e-01 5.000000000000000000e-01 5.000000000000001110e-01 1.000000000000000000e+00 2 | 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 3 | 0.000000000000000000e+00 4.166666666666666852e-01 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 3.999999999999999112e-01 4 | 5.714285714285716189e-01 2.500000000000000000e-01 6.666666666666666297e-01 7.500000000000000000e-01 5.000000000000001110e-01 0.000000000000000000e+00 5 | -------------------------------------------------------------------------------- /09第9章 综合评价方法/Pdata9_1_5.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/09第9章 综合评价方法/Pdata9_1_5.xlsx -------------------------------------------------------------------------------- /10第10章 图论模型/Pdata10_14.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/Pdata10_14.xlsx -------------------------------------------------------------------------------- /10第10章 图论模型/Pdata10_2.txt: -------------------------------------------------------------------------------- 1 | 0.000000000000000000e+00 9.000000000000000000e+00 2.000000000000000000e+00 4.000000000000000000e+00 7.000000000000000000e+00 2 | 0.000000000000000000e+00 0.000000000000000000e+00 3.000000000000000000e+00 4.000000000000000000e+00 0.000000000000000000e+00 3 | 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 8.000000000000000000e+00 4.000000000000000000e+00 4 | 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 6.000000000000000000e+00 5 | 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 6 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_10.py 2 | import numpy as np 3 | import networkx as nx 4 | List=[(1,2,20),(1,5,15),(2,3,20),(2,4,40), 5 | (2,5,25),(3,4,30),(3,5,10),(5,6,15)] 6 | G=nx.Graph() 7 | G.add_nodes_from(range(1,7)) 8 | G.add_weighted_edges_from(List) 9 | c=dict(nx.shortest_path_length(G,weight='weight')) 10 | d=np.zeros((6,6)) 11 | for i in range(1,7): 12 | for j in range(1,7): d[i-1,j-1]=c[i][j] 13 | print(d) 14 | q=np.array([80,90,30,20,60,10]) 15 | m=d@q #计算运力，这里使用矩阵乘法 16 | mm=m.min() #求运力的最小值 17 | ind=np.where(m==mm)[0]+1 #python下标从0开始，np.where返回值为元组 18 | print("运力m=",m,'\n最小运力mm=',mm,"\n选矿厂的设置位置为：",ind) 19 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_13.py 2 | import numpy as np 3 | import networkx as nx 4 | import pylab as plt 5 | L=[(1,2,8),(1,3,4),(1,5,2),(2,3,4),(3,4,2),(3,5,1),(4,5,5)] 6 | b=nx.Graph() 7 | b.add_nodes_from(range(1,6)) 8 | b.add_weighted_edges_from(L) 9 | T=nx.minimum_spanning_tree(b) #返回可迭代对象 10 | w=nx.get_edge_attributes(T,'weight') #提取字典数据 11 | TL=sum(w.values()) #计算最小生成树的长度 12 | print("最小生成树为:",w) 13 | print("最小生成树的长度为：",TL) 14 | pos=nx.shell_layout(b) 15 | nx.draw(T,pos,node_size=280,with_labels=True,node_color='r') 16 | nx.draw_networkx_edge_labels(T,pos,edge_labels=w) 17 | plt.show() 18 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_14.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_14.py 2 | import numpy as np 3 | import networkx as nx 4 | import pandas as pd 5 | import pylab as plt 6 | a=pd.read_excel("Pdata10_14.xlsx",header=None) 7 | b=a.values; b[np.isnan(b)]=0 8 | c=np.zeros((8,8)) #邻接矩阵初始化 9 | c[0:7,1:8]=b #构造图的邻接矩阵 10 | G=nx.Graph(c) 11 | T=nx.minimum_spanning_tree(G) #返回可迭代对象 12 | d=nx.to_numpy_matrix(T) #返回最小生成树的邻接矩阵 13 | print("邻接矩阵c=\n",d) 14 | W=d.sum()/2+5 #求油管长度 15 | print("油管长度W=",W) 16 | s=dict(zip(range(8),range(1,9))) #构造用于顶点标注的标号字典 17 | plt.rc('font',size=16); pos=nx.shell_layout(G) 18 | nx.draw(T,pos,node_size=280,labels=s,node_color='r') 19 | w=nx.get_edge_attributes(T,'weight') 20 | nx.draw_networkx_edge_labels(T,pos,edge_labels=w) 21 | plt.savefig('figure10_14.png'); plt.show() 22 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_15.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_15.py 2 | import numpy as np 3 | import networkx as nx 4 | from networkx.algorithms.matching import max_weight_matching 5 | a=np.array([[3,5,5,4,1],[2,2,0,2,2],[2,4,4,1,0], 6 | [0,2,2,1,0],[1,2,1,3,3]]) 7 | b=np.zeros((10,10)); b[0:5,5:]=a; G=nx.Graph(b) 8 | s0=max_weight_matching(G) #返回值为（人员，工作）的集合 9 | s=[sorted(w) for w in s0] 10 | L1=[x[0] for x in s]; L1=np.array(L1)+1 #人员编号 11 | L2=[x[1] for x in s]; L2=np.array(L2)-4 #工作编号 12 | c=a[L1-1,L2-1] #提取对应的效益 13 | d=c.sum() #计算总的效益 14 | print("工作分配对应关系为：\n人员编号：",L1) 15 | print("工作编号：", L2); print("总的效益为：",d) 16 | 17 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_17.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_17.py 2 | import numpy as np 3 | import networkx as nx 4 | L=[(1,2,5,3),(1,3,3,6),(2,4,2,8),(3,2,1,2),(3,5,4,2), 5 | (4,3,1,1),(4,5,3,4),(4,6,2,10),(5,6,5,2)] 6 | G=nx.DiGraph() 7 | for k in range(len(L)): 8 | G.add_edge(L[k][0]-1,L[k][1]-1, capacity=L[k][2], weight=L[k][3]) 9 | mincostFlow=nx.max_flow_min_cost(G,0,5) 10 | print("所求流为：",mincostFlow) 11 | mincost=nx.cost_of_flow(G, mincostFlow) 12 | print("最小费用为：", mincost) 13 | flow_mat=np.zeros((6,6),dtype=int) 14 | for i,adj in mincostFlow.items(): 15 | for j,f in adj.items(): 16 | flow_mat[i,j]=f 17 | print("最小费用最大流的邻接矩阵为：\n",flow_mat) 18 | 19 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_18.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_18.py 2 | import numpy as np,networkx as nx 3 | import pylab as plt 4 | from scipy.sparse.linalg import eigs 5 | L=[(1,2),(2,3),(2,4),(3,4),(3,5),(3,6), 6 | (4,1),(5,6),(6,1)] 7 | G=nx.DiGraph() 8 | G.add_nodes_from(range(1,7)) #添加顶点集 9 | G.add_edges_from(L) #添加边集 10 | B=np.array(nx.to_numpy_matrix(G)) #提取邻接矩阵 11 | plt.rc('font',size=16); pos=nx.shell_layout(G) 12 | nx.draw(G,pos,node_size=280,font_weight='bold', 13 | node_color='r',with_labels=True) 14 | plt.savefig("figure10_18_1.png") 15 | A=B/np.tile(B.sum(axis=1,keepdims=True),(1,B.shape[1])) 16 | A=0.15/B.shape[0]+0.85*A #计算状态转移概率矩阵 17 | print("A=",A) 18 | W,V=eigs(A.T,1); V=V.real 19 | V=V.flatten(); #展开成（n,)形式的数组 20 | V=V/V.sum(); print("V=",V); plt.figure(2) 21 | plt.bar(range(1,B.shape[0]+1),V, width=0.6, color='b') 22 | plt.savefig("figure10_18_2.png"); plt.show() 23 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_19.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_19.py 2 | import numpy as np 3 | import networkx as nx 4 | L=[(1,2),(1,3),(2,3),(2,4),(2,5),(3,5), 5 | (4,5),(4,6)] 6 | G=nx.Graph() #构造无向图 7 | G.add_nodes_from(range(1,7)) #添加顶点集 8 | G.add_edges_from(L) 9 | D=nx.diameter(G) #求网络直径 10 | LH=nx.average_shortest_path_length(G) #求平均路径长度 11 | Ci=nx.clustering(G) #求各顶点的聚类系数 12 | C=nx.average_clustering(G) #求整个网络的聚类系数 13 | print("网络直径为：",D,"\n平均路径长度为：",LH) 14 | print("各顶点的聚类系数为：") 15 | for index,value in enumerate(Ci.values()): 16 | print("(顶点v{:d}: {:.4f})；".format(index+1,value),end=' ') 17 | print("\n整个网络的聚类系数为：{:.4f}".format(C)) 18 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_2_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_2_1.py 2 | import numpy as np 3 | import networkx as nx 4 | import pylab as plt 5 | a=np.zeros((5,5)) 6 | a[0,1:5]=[9, 2, 4, 7]; a[1,2:4]=[3,4] 7 | a[2,[3,4]]=[8, 4]; #输入邻接矩阵的上三角元素 8 | a[3,4]=6; print(a); np.savetxt("Pdata10_2.txt",a) #保存邻接矩阵供以后使用 9 | i,j=np.nonzero(a) #提取顶点的编号 10 | w=a[i,j] #提出a中的非零元素 11 | edges=list(zip(i,j,w)) 12 | G=nx.Graph() 13 | G.add_weighted_edges_from(edges) 14 | key=range(5); s=[str(i+1) for i in range(5)] 15 | s=dict(zip(key,s)) #构造用于顶点标注的字符字典 16 | plt.rc('font',size=18) 17 | plt.subplot(121); nx.draw(G,font_weight='bold',labels=s) 18 | plt.subplot(122); pos=nx.shell_layout(G) #布局设置 19 | nx.draw_networkx(G,pos,node_size=260,labels=s) 20 | w = nx.get_edge_attributes(G,'weight') 21 | nx.draw_networkx_edge_labels(G,pos,font_size=12,edge_labels=w) #标注权重 22 | plt.savefig("figure10_2.png", dpi=500); plt.show() 23 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_2_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_2_2.py 2 | import networkx as nx 3 | import pylab as plt 4 | import numpy as np 5 | List=[(1,2,9),(1,3,2),(1,4,4),(1,5,7), 6 | (2,3,3),(2,4,4),(3,4,8),(3,5,4),(4,5,6)] 7 | G=nx.Graph() 8 | G.add_nodes_from(range(1,6)) 9 | G.add_weighted_edges_from(List) 10 | pos=nx.shell_layout(G) 11 | w = nx.get_edge_attributes(G,'weight') 12 | nx.draw(G, pos,with_labels=True, font_weight='bold',font_size=12) 13 | nx.draw_networkx_edge_labels(G,pos,edge_labels=w) 14 | plt.show() 15 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_3.py 2 | import numpy as np 3 | import networkx as nx 4 | import pylab as plt 5 | G=nx.DiGraph() 6 | List=[(1,2),(1,3),(2,3),(3,2),(3,5),(4,2),(4,6), 7 | (5,2),(5,4),(5,6),(6,5)] 8 | G.add_nodes_from(range(1,7)) 9 | G.add_edges_from(List) 10 | plt.rc('font',size=16) 11 | pos=nx.shell_layout(G) 12 | nx.draw(G,pos,with_labels=True, font_weight='bold',node_color='r') 13 | plt.savefig("figure10_3.png", dpi=500); plt.show() 14 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_4.py 2 | import numpy as np 3 | import networkx as nx 4 | import pylab as plt 5 | a=np.loadtxt("Pdata10_2.txt") 6 | G=nx.Graph(a) #利用邻接矩阵构造赋权无向图 7 | print("图的顶点集为：", G.nodes(),"\n边集为：", G.edges()) 8 | print("邻接表为：", list(G.adjacency())) #显示图的邻接表 9 | print("列表字典为：", nx.to_dict_of_lists(G)) 10 | B=nx.to_numpy_matrix(G) #从图G中导出邻接矩阵B，这里B=a 11 | C=nx.to_scipy_sparse_matrix(G) #从图G中导出稀疏矩阵C 12 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_5.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/Pex10_5.xlsx -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_6.py 2 | import numpy as np 3 | import networkx as nx 4 | List=[(0,1,1),(0,2,2),(0,4,7),(0,6,4),(0,7,8),(1,2,2),(1,3,3), 5 | (1,7,7),(2,3,1),(2,4,5),(3,4,3),(3,5,6),(4,5,4),(4,6,3), 6 | (5,6,6),(5,7,4),(6,7,2)] 7 | G=nx.Graph() 8 | G.add_weighted_edges_from(List) 9 | A=nx.to_numpy_matrix(G, nodelist=range(8)) #导出邻接矩阵 10 | np.savetxt('Pdata10_6.txt',A) 11 | p=nx.dijkstra_path(G, source=3, target=7, weight='weight') #求最短路径； 12 | d=nx.dijkstra_path_length(G, 3, 7, weight='weight') #求最短距离 13 | print("最短路径为：",p,"；最短距离为：",d) 14 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_7.py: -------------------------------------------------------------------------------- 1 | #程序文件py10_7.py 2 | import numpy as np 3 | def floyd(graph): 4 | m = len(graph) 5 | dis = graph 6 | path = np.zeros((m, m)) #路由矩阵初始化 7 | for k in range(m): 8 | for i in range(m): 9 | for j in range(m): 10 | if dis[i][k] + dis[k][j] < dis[i][j]: 11 | dis[i][j] = dis[i][k] + dis[k][j] 12 | path[i][j] = k 13 | return dis, path 14 | inf=np.inf 15 | a=np.array([[0,1,2,inf,7,inf,4,8],[1,0,2,3,inf,inf,inf,7], 16 | [2,2,0,1,5,inf,inf,inf],[inf,3,1,0,3,6,inf,inf], 17 | [7,inf,5,3,0,4,3,inf],[inf,inf,inf,6,4,0,6,4], 18 | [4,inf,inf,inf,3,6,0,2],[8,7,inf,inf,inf,4,2,0]]) #输入邻接矩阵 19 | dis, path=floyd(a) 20 | print("所有顶点对之间的最短距离为：\n", dis, '\n',"路由矩阵为：\n",path) 21 | -------------------------------------------------------------------------------- /10第10章 图论模型/Pex10_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex10_8.py 2 | import numpy as np 3 | import networkx as nx 4 | a=np.loadtxt("Pdata10_6.txt") 5 | G=nx.Graph(a) #利用邻接矩阵构造赋权无向图 6 | d=nx.shortest_path_length(G,weight='weight') #返回值是可迭代类型 7 | Ld=dict(d) #转换为字典类型 8 | print("顶点对之间的距离为：",Ld) #显示所有顶点对之间的最短距离 9 | print("顶点0到顶点4的最短距离为:",Ld[0][4]) #显示一对顶点之间的最短距离 10 | m,n=a.shape; dd=np.zeros((m,n)) 11 | for i in range(m): 12 | for j in range(n): dd[i,j]=Ld[i][j] 13 | print("顶点对之间最短距离的数组表示为：\n",dd) #显示所有顶点对之间最短距离 14 | np.savetxt('Pdata10_8.txt',dd) #把最短距离数组保存到文本文件中 15 | p=nx.shortest_path(G, weight='weight') #返回值是可迭代类型 16 | dp=dict(p) #转换为字典类型 17 | print("\n顶点对之间的最短路径为：", dp) 18 | print("顶点0到顶点4的最短路径为：",dp[0][4]) 19 | -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_12.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_14.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_14.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_18_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_18_1.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_18_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_18_2.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_2.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_3.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_7.png -------------------------------------------------------------------------------- /10第10章 图论模型/figure10_9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/10第10章 图论模型/figure10_9.png -------------------------------------------------------------------------------- /10第10章 图论模型/myfloyd.py: -------------------------------------------------------------------------------- 1 | #程序文件py10_6.py 2 | import numpy as np 3 | def floyd(graph): 4 | m = len(graph) 5 | dis = graph 6 | path = np.zeros((m, m)) #路由矩阵初始化 7 | for k in range(m): 8 | for i in range(m): 9 | for j in range(m): 10 | if dis[i][k] + dis[k][j] < dis[i][j]: 11 | dis[i][j] = dis[i][k] + dis[k][j] 12 | path[i][j] = k 13 | 14 | return dis, path 15 | inf=np.inf 16 | a=[[0,50,inf,40,25,10],[50,0,15,20,inf,25], 17 | [inf,15,0,10,20,inf],[40,20,10,0,10,25], 18 | [25,inf,20,10,0,55],[10,25,inf,25,55,0]] #输入邻接矩阵 19 | dis, path=floyd(a) 20 | print("所有顶点对之间的最短距离为：\n", dis, '\n',"路由矩阵为：\n",path) 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pan11_1_1.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/Pan11_1_1.xlsx -------------------------------------------------------------------------------- /11第11章 多元分析/Pan11_1_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/Pan11_1_2.xlsx -------------------------------------------------------------------------------- /11第11章 多元分析/Pdata11_11.txt: -------------------------------------------------------------------------------- 1 | 2.9909 3.2044 2.8392 2.5315 2.5897 2.9600 3.1184 2 | 0.3111 0.5348 0.5696 0.4528 0.3010 3.0480 2.8395 3 | 0.5324 0.7718 0.7614 0.4893 0.2735 1.4997 1.9850 4 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pdata11_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/Pdata11_2.xlsx -------------------------------------------------------------------------------- /11第11章 多元分析/Pdata11_7.txt: -------------------------------------------------------------------------------- 1 | 1 149.5 69.5 38.5 6 156.1 74.5 45.5 2 | 2 162.5 77 55.5 7 172.0 76.5 51.0 3 | 3 162.7 78.5 50.8 8 173.2 81.5 59.5 4 | 4 162.2 87.5 65.5 9 159.5 74.5 43.5 5 | 5 156.5 74.5 49.0 10 157.7 79 53.5 6 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pdata11_8.txt: -------------------------------------------------------------------------------- 1 | 1932.27 1900.53 653.83 570.95 1810.70 119.53 2 | 367.05 366.08 186.16 252.07 395.43 32.82 3 | 86.89 85.38 40.85 51.71 83.26 8.95 4 | 154.27 147.07 30.68 57.96 146.30 -1.27 5 | 197.21 193.28 104.56 90.15 182.60 7.85 6 | 244.17 231.55 56.37 121.96 224.04 26.49 7 | 497.74 483.69 206.80 501.37 496.59 27.76 8 | 308.91 296.99 118.65 76.90 277.42 19.32 9 | 191.77 189.05 70.19 62.31 191.98 23.08 10 | 905.32 894.61 351.52 502.99 1048.02 53.88 11 | 254.99 242.38 106.66 75.48 234.76 19.65 12 | 867.07 852.34 418.82 217.76 806.94 37.01 13 | 219.36 207.07 82.58 54.74 192.74 11.02 14 | 570.33 563.33 224.23 190.77 697.91 20.61 15 | 59.11 57.32 16.97 40.33 56.56 6.03 16 | 430.58 426.25 103.08 147.05 442.04 0.79 17 | 65.03 64.36 28.38 8.58 60.48 2.88 18 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_1.py 2 | import numpy as np 3 | from sklearn.neighbors import KNeighborsClassifier 4 | x0=np.array([[1.24,1.27], [1.36,1.74], [1.38,1.64], [1.38,1.82], [1.38,1.90], [1.40,1.70], 5 | [1.48,1.82], [1.54,1.82], [1.56,2.08], [1.14,1.78], [1.18,1.96], [1.20,1.86], 6 | [1.26,2.00], [1.28,2.00], [1.30,1.96]]) #输入已知样本数据 7 | x=np.array([[1.24,1.80], [1.28,1.84], [1.40,2.04]]) #输入待判样本点数据 8 | g=np.hstack([np.ones(9),2*np.ones(6)]) #g为已知样本数据的类别标号 9 | v=np.cov(x0.T) #计算协方差 10 | knn=KNeighborsClassifier(2,metric='mahalanobis',metric_params={'V': v}) #马氏距离分类 11 | knn.fit(x0,g); pre=knn.predict(x); print("马氏距离分类结果：",pre) 12 | print("马氏距离已知样本的误判率为：",1-knn.score(x0,g)) 13 | knn2=KNeighborsClassifier(2) #欧氏距离分类 14 | knn2.fit(x0,g); pre2=knn2.predict(x); print("欧氏距离分类结果：",pre2) 15 | print("欧氏距离已知样本的误判率为：",1-knn2.score(x0,g)) 16 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_10.py 2 | import numpy as np 3 | from sklearn.decomposition import FactorAnalysis 4 | r=np.array([[1, 1/5, -1/5],[1/5, 1, -2/5],[-1/5, -2/5, 1]]) 5 | fa=FactorAnalysis() 6 | r_fa=fa.fit(r) 7 | print(r_fa.get_params()) 8 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_11.py 2 | import numpy as np 3 | from sklearn import preprocessing as pp 4 | import scipy.cluster.hierarchy as sch 5 | import matplotlib.pyplot as plt 6 | a=np.loadtxt("Pdata11_11.txt") 7 | b=pp.minmax_scale(a.T) #数据规格化 8 | d = sch.distance.pdist(b) #求对象之间的两两距离向量 9 | dd = sch.distance.squareform(d) #转换为矩阵格式 10 | z=sch.linkage(d); print(z) #进行聚类并显示 11 | s=[str(i+1) for i in range(7)]; plt.rc('font',size=16) 12 | sch.dendrogram(z,labels=s); plt.show() #画聚类图 13 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_12.py 2 | import numpy as np 3 | from sklearn import preprocessing as pp 4 | import scipy.cluster.hierarchy as sch 5 | import matplotlib.pyplot as plt 6 | a=np.loadtxt("Pdata11_11.txt") 7 | b=pp.minmax_scale(a.T) #数据规格化 8 | d = sch.distance.pdist(b) #求对象之间的两两距离向量 9 | z=sch.linkage(d,'complete'); print(z) #进行聚类并显示 10 | s=[str(i+1) for i in range(7)]; plt.rc('font',size=16) 11 | sch.dendrogram(z,labels=s); plt.show() #画聚类图 12 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_13.py 2 | import numpy as np 3 | from sklearn.cluster import KMeans 4 | a=np.array([[1, 3],[1.5, 3.2],[1.3, 2.8],[3, 1]]) 5 | md=KMeans(n_clusters=2) #构建模型 6 | md.fit(a) #求解模型 7 | labels=1+md.labels_ #提取聚类标签 8 | centers=md.cluster_centers_ #提取聚类中心,每一行是一个聚类中心 9 | print(labels,'\n-----------\n',centers) 10 | 11 | 12 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_2.py 2 | import numpy as np 3 | import pandas as pd 4 | from sklearn.neighbors import KNeighborsClassifier 5 | a=pd.read_excel("Pdata11_2.xlsx",header=None) 6 | b=a.values 7 | x0=b[:-2,1:-1].astype(float) #提取已知样本点的观测值 8 | y0=b[:-2,-1].astype(int) 9 | x=b[-2:,1:-1] #提取待判样本点的观察值 10 | v=np.cov(x0.T) #计算协方差 11 | knn=KNeighborsClassifier(3,metric='mahalanobis',metric_params={'V': v}) #马氏距离分类 12 | knn.fit(x0,y0); pre=knn.predict(x); print("分类结果：",pre) 13 | print("已知样本的误判率为：",1-knn.score(x0,y0)) 14 | 15 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_3.py 2 | import numpy as np 3 | from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA 4 | x0=np.array([[1.24,1.27], [1.36,1.74], [1.38,1.64], [1.38,1.82], [1.38,1.90], [1.40,1.70], 5 | [1.48,1.82], [1.54,1.82], [1.56,2.08], [1.14,1.78], [1.18,1.96], [1.20,1.86], 6 | [1.26,2.00], [1.28,2.00], [1.30,1.96]]) #输入已知样本数据 7 | x=np.array([[1.24,1.80], [1.28,1.84], [1.40,2.04]]) #输入待判样本点数据 8 | y0=np.hstack([np.ones(9),2*np.ones(6)]) #y0为已知样本数据的类别 9 | clf = LDA() 10 | clf.fit(x0, y0) 11 | print("判别结果为：",clf.predict(x)) 12 | print("已知样本的误判率为：",1-clf.score(x0,y0)) 13 | 14 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_4.py 2 | import numpy as np 3 | import pandas as pd 4 | from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA 5 | a=pd.read_excel("Pdata11_2.xlsx",header=None) 6 | b=a.values 7 | x0=b[:-2,1:-1].astype(float) #提取已知样本点的观测值 8 | y0=b[:-2,-1].astype(int) 9 | x=b[-2:,1:-1] #提取待判样本点的观察值 10 | clf = LDA() 11 | clf.fit(x0, y0) 12 | print("判别结果为：",clf.predict(x)) 13 | print("已知样本的误判率为：",1-clf.score(x0,y0)) 14 | 15 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_5.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from sklearn.naive_bayes import GaussianNB 3 | x0=np.array([[1.24,1.27], [1.36,1.74], [1.38,1.64], [1.38,1.82], [1.38,1.90], [1.40,1.70], 4 | [1.48,1.82], [1.54,1.82], [1.56,2.08], [1.14,1.78], [1.18,1.96], [1.20,1.86], 5 | [1.26,2.00], [1.28,2.00], [1.30,1.96]]) #输入已知样本数据 6 | x=np.array([[1.24,1.80], [1.28,1.84], [1.40,2.04]]) #输入待判样本点数据 7 | y0=np.hstack([np.ones(9),2*np.ones(6)]) #y0为已知样本数据的类别 8 | clf = GaussianNB() 9 | clf.fit(x0, y0) 10 | print("判别结果为：",clf.predict(x)) 11 | print("已知样本的误判率为：",1-clf.score(x0,y0)) 12 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_6.py 2 | import numpy as np 3 | import pandas as pd 4 | from sklearn.discriminant_analysis import \ 5 | LinearDiscriminantAnalysis 6 | from sklearn.model_selection import cross_val_score 7 | a=pd.read_excel("Pdata11_2.xlsx",header=None) 8 | b=a.values 9 | x0=b[:-2,1:-1].astype(float) #提取已知样本点的观测值 10 | y0=b[:-2,-1].astype(int) 11 | model = LinearDiscriminantAnalysis () 12 | print(cross_val_score(model, x0, y0,cv=2)) 13 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_7.py 2 | import numpy as np 3 | from sklearn.decomposition import PCA 4 | a=np.loadtxt("Pdata11_7.txt") 5 | b=np.r_[a[:,1:4],a[:,-3:]] #构造数据矩阵 6 | md=PCA().fit(b) #构造并训练模型 7 | print("特征值为：",md.explained_variance_) 8 | print("各主成分的贡献率：",md.explained_variance_ratio_) 9 | print("奇异值为：",md.singular_values_) 10 | print("各主成分的系数：\n",md.components_) #每行是一个主成分 11 | """下面直接计算特征值和特征向量，和库函数进行对比""" 12 | cf=np.cov(b.T) #计算协方差阵 13 | c,d=np.linalg.eig(cf) #求特征值和特征向量 14 | print("特征值为：",c) 15 | print("特征向量为：\n",d) 16 | print("各主成分的贡献率为：",c/np.sum(c)) 17 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_8.py 2 | import numpy as np 3 | from scipy.stats import zscore 4 | a=np.loadtxt("Pdata11_8.txt") 5 | print("相关系数阵为：\n",np.corrcoef(a.T)) 6 | b=np.delete(a,0,axis=1) #删除第1列数据 7 | c=zscore(b); r=np.corrcoef(c.T) #数据标准化并计算相关系数阵 8 | d,e=np.linalg.eig(r) #求特征值和特征向量 9 | rate=d/d.sum() #计算各主成分的贡献率 10 | print("特征值为：",d) 11 | print("特征向量为：\n",e) 12 | print("各主成分的贡献率为：",rate) 13 | k=1; #提出主成分的个数 14 | F=e[:,:k]; score_mat=c.dot(F) #计算主成分得分矩阵 15 | score1=score_mat.dot(rate[0:k]) #计算各评价对象的得分 16 | score2=-score1 #通过观测，调整得分的正负号 17 | print("各评价对象的得分为：",score2) 18 | index=score1.argsort()+1 #排序后的每个元素在原数组中的位置 19 | print("从高到低各个城市的编号排序为：",index) 20 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pex11_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex11_9.py 2 | import numpy as np 3 | r=np.array([[1, 1/5, -1/5],[1/5, 1, -2/5],[-1/5, -2/5, 1]]) 4 | [val,vec]=np.linalg.eig(r) #求相关系数阵的特征值和特征向量 5 | A1=np.tile(np.sqrt(val),(3,1))*vec 6 | A2=vec*np.sqrt(val) #利用广播运算求载荷矩阵 7 | print('val:',val,'\n---------\n',A1,'\n----------\n',A2) 8 | num=int(input("请输入选择公共因子的个数：")) 9 | A=A1[:,:num] #提出num个因子的载荷矩阵 10 | Ac=np.sum(A**2, axis=0) #逐列元素求和 11 | Ar=np.sum(A**2, axis=1) #逐行元素求和 12 | print("对x的贡献为：",Ac) 13 | print("共同度为：",Ar) 14 | 15 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pz11_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz11_2.py 2 | import numpy as np; import matplotlib.pyplot as plt 3 | from sklearn.cluster import KMeans; from sklearn import metrics 4 | X=np.load("Pzdata11_1.npy") 5 | S=[]; K=10 6 | for k in range(2,K+1): 7 | md = KMeans(k); md.fit(X) 8 | labels = md.labels_; 9 | S.append(metrics.silhouette_score(X,labels,metric='euclidean')) #计算轮廓系数 10 | plt.rc('font',size=16); plt.rc('font',family='SimHei') 11 | plt.plot(range(2,K+1), S, 'b*-') 12 | plt.xlabel('簇的个数'); plt.ylabel('轮廓系数'); plt.show() 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pz11_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz11_3 2 | import numpy as np; import matplotlib.pyplot as plt 3 | from sklearn.cluster import KMeans; from sklearn import metrics 4 | X=np.load("Pzdata11_1.npy") 5 | TSSE=[]; K=10 6 | for k in range(1,K+1): 7 | SSE = [] 8 | md = KMeans(n_clusters=k); md.fit(X) 9 | labels = md.labels_; centers = md.cluster_centers_ 10 | for label in set(labels): 11 | SSE.append(np.sum((X[labels == label,:]-centers[label,:])**2)) 12 | TSSE.append(np.sum(SSE)) 13 | plt.rc('font',family='SimHei'); 14 | plt.style.use('ggplot'); plt.plot(range(1,K+1), TSSE, 'b*-') 15 | plt.xlabel('簇的个数'); 16 | plt.ylabel('簇内离差平方和之和'); plt.show() 17 | 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /11第11章 多元分析/Pzdata11_1.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/Pzdata11_1.npy -------------------------------------------------------------------------------- /11第11章 多元分析/figure11_11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/figure11_11.png -------------------------------------------------------------------------------- /11第11章 多元分析/figure11_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/figure11_12.png -------------------------------------------------------------------------------- /11第11章 多元分析/figureZ_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/figureZ_3.png -------------------------------------------------------------------------------- /11第11章 多元分析/figureZ_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/figureZ_4.png -------------------------------------------------------------------------------- /11第11章 多元分析/figure_an1_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/11第11章 多元分析/figure_an1_1.png -------------------------------------------------------------------------------- /12第12章 回归分析/Pdata12_1.txt: -------------------------------------------------------------------------------- 1 | 7 26 78.5 2 | 1 29 74.3 3 | 11 56 104.3 4 | 11 31 87.6 5 | 7 52 95.9 6 | 11 55 109.2 7 | 3 71 102.7 8 | 1 31 72.5 9 | 2 54 93.1 10 | 21 47 115.9 11 | 1 40 83.8 12 | 11 66 113.3 13 | 10 68 109.4 14 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pdata12_3.txt: -------------------------------------------------------------------------------- 1 | 149.3 4.2 108.1 15.9 2 | 171.5 4.1 114.8 16.4 3 | 175.5 3.1 123.2 19.0 4 | 180.8 3.1 126.9 19.1 5 | 190.7 1.1 132.1 18.8 6 | 202.1 2.2 137.7 20.4 7 | 202.1 2.1 146.0 22.7 8 | 212.4 5.6 154.1 26.5 9 | 226.1 5.0 162.3 28.1 10 | 231.9 5.1 164.3 27.6 11 | 239.0 0.7 167.6 26.3 12 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pdata12_6.txt: -------------------------------------------------------------------------------- 1 | 3496.2 3.43 136.69 111.78 205.42 2 | 4283 3.52 145.27 115.7 249.96 3 | 4838.9 3.73 147.52 118.58 289.67 4 | 5160.3 3.94 158.25 122.64 358.36 5 | 5425.1 4.16 163 127.85 423.65 6 | 5854 4.37 183.2 135.17 533.88 7 | 6280 4.59 207 140.27 625.33 8 | 6859.6 4.81 234.17 169.8 770.78 9 | 7702.8 5.02 325.1 176.52 968.98 10 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pdata12_7_1.txt: -------------------------------------------------------------------------------- 1 | 1.5 25 8 2 | 2.5 32 13 3 | 3.5 58 26 4 | 4.5 52 22 5 | 5.5 43 20 6 | 6.5 39 22 7 | 7.5 28 16 8 | 8.5 21 12 9 | 9.5 15 10 10 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pdata12_7_2.txt: -------------------------------------------------------------------------------- 1 | -8.862696682172253038e-01 2 | 1.557969654380223778e-01 3 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pdata12_9.txt: -------------------------------------------------------------------------------- 1 | -62.3 -89.5 1.7 0 2 | 3.3 -3.5 1.1 0 3 | -120.8 -103.2 2.5 0 4 | -18.1 -28.8 1.1 0 5 | -3.8 -50.6 0.9 0 6 | -61.2 -56.2 1.7 0 7 | -20.3 -17.4 1 0 8 | -194.5 -25.8 0.5 0 9 | 20.8 -4.3 1 0 10 | -106.1 -22.9 1.5 0 11 | 43 16.4 1.3 1 12 | 47 16 1.9 1 13 | -3.3 4 2.7 1 14 | 35 20.8 1.9 1 15 | 46.7 12.6 0.9 1 16 | 20.8 12.5 2.4 1 17 | 33 23.6 1.5 1 18 | 26.1 10.4 2.1 1 19 | 68.6 13.8 1.6 1 20 | 37.3 33.4 3.5 1 21 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_1.py 2 | import numpy as np 3 | from sklearn.linear_model import LinearRegression 4 | a=np.loadtxt("Pdata12_1.txt") #加载表中x1,x2,y的13行3列数据 5 | md=LinearRegression().fit(a[:,:2],a[:,2]) #构建并拟合模型 6 | y=md.predict(a[:,:2]) #求预测值 7 | b0=md.intercept_; b12=md.coef_ #输出回归系数 8 | R2=md.score(a[:,:2],a[:,2]) #计算R^2 9 | print("b0=%.4f\nb12=%.4f%10.4f"%(b0,b12[0],b12[1])) 10 | print("拟合优度R^2=%.4f"%R2) 11 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_10.py 2 | import numpy as np 3 | from sklearn.linear_model import LogisticRegression 4 | a=np.loadtxt("Pdata12_9.txt") 5 | n=a.shape[1] #提取矩阵的列数 6 | x=a[:,:n-1]; y=a[:,n-1] 7 | md=LogisticRegression(solver='lbfgs') 8 | md=md.fit(x,y) 9 | print(md.intercept_,md.coef_) 10 | print(md.predict(x)) #检验预测模型 11 | print(md.predict([[-49.2,-17.2,0.3],[40.6,26.4,1.8]])) #求预测值 12 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_2_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_2_1.py 2 | import numpy as np; import statsmodels.api as sm 3 | a=np.loadtxt("Pdata12_1.txt") 4 | #加载表中x1,x2,y的13行3列数据（数据见封底二维码） 5 | d={'x1':a[:,0],'x2':a[:,1],'y':a[:,2]} 6 | md=sm.formula.ols('y~x1+x2',d).fit() #构建并拟合模型 7 | print(md.summary(),'\n------------\n') #显示模型所有信息 8 | ypred=md.predict({'x1':a[:,0],'x2':a[:,1]}) #计算预测值 9 | print(ypred) #输出预测值 10 | 11 | 12 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_2_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_2_2.py 2 | import numpy as np; import statsmodels.api as sm 3 | a=np.loadtxt("Pdata12_1.txt") 4 | #加载表中x1,x2,y的13行3列数据（数据见封底二维码） 5 | X = sm.add_constant(a[:,:2]) #增加第一列全部元素为1得到增广矩阵 6 | md=sm.OLS(a[:,2],X).fit() #构建并拟合模型 7 | print(md.params,'\n------------\n') #提取所有回归系数 8 | y=md.predict(X) #求已知自变量值的预测值 9 | print(md.summary2()) #输出模型的所有结果 10 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_3.py 2 | import numpy as np; import statsmodels.api as sm 3 | a=np.loadtxt("Pdata12_3.txt") #加载表中x1,x2,x3,y的11行4列数据 4 | x=a[:,:3] #提出自变量观测值矩阵 5 | X=sm.add_constant(x) #增加第一列全部元素为1得到增广矩阵 6 | md=sm.OLS(a[:,3],X).fit() #构建并拟合模型 7 | b=md.params #提取所有回归系数 8 | y=md.predict(X) #求已知自变量值的预测值 9 | print(md.summary()) #输出模型的所有结果 10 | print("相关系数矩阵:\n",np.corrcoef(x.T)) 11 | X1=sm.add_constant(a[:,0]) 12 | md1=sm.OLS(a[:,2],X1).fit() 13 | print("回归系数为：",md1.params) 14 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_7.py 2 | import numpy as np 3 | import statsmodels.api as sm 4 | a=np.loadtxt("Pdata12_7_1.txt") #加载表中x,ni,mi的9行3列数据 5 | x=a[:,0]; pi=a[:,2]/a[:,1] 6 | X=sm.add_constant(x); yi=np.log(pi/(1-pi)) 7 | md=sm.OLS(yi,X).fit() #构建并拟合模型 8 | print(md.summary()) #输出模型的所有结果 9 | b=md.params #提出所有的回归系数 10 | p0=1/(1+np.exp(-np.dot(b,[1,9]))) 11 | print("所求概率p0=%.4f"%p0) 12 | np.savetxt("Pdata12_7_2.txt", b) #把回归系数保存到文本文件 13 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex12_8.py 2 | import numpy as np 3 | b=np.loadtxt("Pdata12_7_2.txt") 4 | odds9=np.exp(np.dot(b,[1,9])) 5 | odds9vs8=np.exp(np.dot([1,9],b))/np.exp(np.dot([1,8],b)) 6 | print("odds9=%.4f,odds9vs8=%.4f"%(odds9,odds9vs8)) 7 | 8 | -------------------------------------------------------------------------------- /12第12章 回归分析/Pex12_9.py: -------------------------------------------------------------------------------- 1 | #程序文件 Pex12_9.py 2 | import numpy as np 3 | import statsmodels.api as sm 4 | a=np.loadtxt("Pdata12_9.txt") 5 | n=a.shape[1] #提取矩阵的列数 6 | x=a[:,:n-1]; y=a[:,n-1] 7 | md=sm.Logit(y,x) 8 | md=md.fit(method="bfgs") #这里必须使用bfgs方法，使用默认牛顿方法出错 9 | print(md.params,'\n----------\n'); print(md.summary2()) 10 | print(md.predict([[-49.2,-17.2,0.3],[40.6,26.4,1.8]])) #求预测值 11 | -------------------------------------------------------------------------------- /12第12章 回归分析/figure12_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/12第12章 回归分析/figure12_1.png -------------------------------------------------------------------------------- /12第12章 回归分析/figure12_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/12第12章 回归分析/figure12_2.png -------------------------------------------------------------------------------- /12第12章 回归分析/gtable11_3.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/12第12章 回归分析/gtable11_3.xlsx -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pdata13_6.txt: -------------------------------------------------------------------------------- 1 | 9.6 18.3 29.0 47.2 71.1 119.1 174.6 257.3 350.7 441.0 513.3 559.7 594.8 629.4 640.8 651.1 655.9 659.6 661.8 -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_1.py 2 | from sympy import Function, rsolve 3 | from sympy.abc import n 4 | y = Function('y') 5 | f=y(n+2)-y(n+1)-y(n) 6 | ff=rsolve(f, y(n),{y(1):1,y(2):1}) 7 | print(ff) 8 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_2.py 2 | import sympy as sp 3 | sp.var('k'); sp.var('y',cls=sp.Function) 4 | f = y(k+1)-y(k)-3-2*k 5 | f1 = sp.rsolve(f, y(k)); f2 = sp.simplify(f1) 6 | print(f2) 7 | 8 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_3.py 2 | x0=1000000; r=0.005; N=500; n=0; xm=8000 3 | x1=x0*(1+r)-xm 4 | while n<=N and x1>0: 5 | n+=1; 6 | if n%12==0: print("第%d个月末欠钱：x(%d)=%.4f"%(n,n,x1)) 7 | x0=x1; x1=x0*(1+r)-xm 8 | print("还款月数n=",n+1) 9 | print("还款%d年%d个月"%((n+1)//12,n+1-12*((n+1)//12))) 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_5.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | 5 | def fun(delta,*str): 6 | w=100; tw=[] 7 | for k in range(1,11): 8 | w=delta*w+2.5-0.125*k; tw.append(w) 9 | print(tw); w2=tw[-1] #提取第二阶段的初值 10 | tw2=[]; k=0 11 | while w2>=75: 12 | k+=1; w2=delta*w2+1.25; 13 | tw2.append(w2); tw.append(w2) 14 | print("k=%d时,w(%d)=%.4f"%(k,k,w2)) 15 | 16 | plt.plot(np.arange(1,len(tw)+1),tw,str[0]) 17 | 18 | fun(0.975,"s-") 19 | fun(0.97,"*-") 20 | 21 | plt.legend(("正常代谢","增加运动"),prop={'family': 'SimHei', 'size': 15}) 22 | plt.show() 23 | 24 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_5_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_5_1.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | plt.rc('font', family='SimHei'); plt.rc('font',size=16) 5 | def fun(delta,*s): 6 | w=100; tw=[] 7 | for k in range(1,11): 8 | w=delta*w+2.5-0.125*k; tw.append(w) 9 | print(tw); w2=tw[-1] #提取第二阶段的初值 10 | tw2=[]; k=0 11 | while w2>=75: 12 | k+=1; w2=delta*w2+1.25; 13 | tw2.append(w2); tw.append(w2) 14 | print("k=%d时,w(%d)=%.4f"%(k,k,w2)) 15 | plt.plot(np.arange(1,len(tw)+1),tw,s[0]) #传入的s是tuple类型 16 | 17 | fun(0.975,"s-"); fun(0.97,"*-") 18 | plt.legend(("正常代谢","增加运动")) 19 | plt.xlabel("$k$/周"); plt.ylabel("$w$/kg") 20 | plt.show() 21 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_5_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_5_2.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | 5 | def fun(delta,*str): 6 | w=100; tw=[] 7 | for k in range(1,11): 8 | w=delta*w+2.5-0.125*k; tw.append(w) 9 | print(tw); w2=tw[-1] #提取第二阶段的初值 10 | tw2=[]; k=0 11 | while w2>=75: 12 | k+=1; w2=delta*w2+1.25; 13 | tw2.append(w2); tw.append(w2) 14 | print("k=%d时,w(%d)=%.4f"%(k,k,w2)) 15 | plt.plot(np.arange(1,len(tw)+1),tw,str[0]) 16 | 17 | def fun2(datas,labels): 18 | for data, style in datas: 19 | fun(data, style) 20 | plt.legend(labels, prop={'family': 'SimHei', 'size': 16}) 21 | plt.show() 22 | 23 | fun2([(0.975,"s-"),(0.97,"*-")],("正常代谢","增加运动")) 24 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_5_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_5_3.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | 5 | def fun(delta,*str): 6 | w=100; tw=[] 7 | for k in range(1,11): 8 | w=delta*w+2.5-0.125*k; tw.append(w) 9 | print(tw); w2=tw[-1] #提取第二阶段的初值 10 | tw2=[]; k=0 11 | while w2>=75: 12 | k+=1; w2=delta*w2+1.25; 13 | tw2.append(w2); tw.append(w2) 14 | print("k=%d时,w(%d)=%.4f"%(k,k,w2)) 15 | plt.plot(np.arange(1,len(tw)+1),tw,str[0]) 16 | 17 | def fun2(datas,labels): 18 | for data, style in datas: 19 | fun(data, style) 20 | plt.legend(labels, prop={'family': 'SimHei', 'size': 16}) 21 | plt.show() 22 | 23 | fun2([(0.975,"s-"),(0.97,"*-")],("正常代谢","增加运动")) 24 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_6.py 2 | import numpy as np 3 | from matplotlib.pyplot import rc, plot, show, legend, figure 4 | rc('font',size=16); rc('font',family='SimHei') 5 | a=np.loadtxt("Pdata13_6.txt"); 6 | plot(np.arange(0,19),a,'*'); show() 7 | b=np.c_[a[:-1],-a[:-1]**2] 8 | c=np.diff(a); x=np.linalg.pinv(b).dot(c) 9 | r=x[0]; N=x[0]/x[1] 10 | print("r,s,N的拟合值分别为：",r,'\t',x[1],'\t',N) 11 | Tx=np.zeros(19); Tx[0]=9.6; x0=9.6 12 | for i in range(1,19): 13 | xn=x0+r*x0*(1-x0/N) 14 | Tx[i]=xn; x0=xn 15 | figure; plot(np.arange(0,19),a,'*') 16 | plot(np.arange(19), Tx,'o-') 17 | legend(("原始数据点","拟合值"), loc='best'); show() 18 | delta=np.abs((Tx-a)/a); 19 | print("所有已知点的预测值的相对误差",delta) 20 | print("最大相对误差:",delta.max()) 21 | 22 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_7_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_7_1.py 2 | import sympy as sp 3 | a0,b0, c0=sp.symbols('a0 b0 c0') 4 | n=sp.symbols('n',positive=True) 5 | A=sp.Matrix([[1,1/2,0],[0,1/2,1],[0,0,0]]) 6 | if A.is_diagonalizable(): print("A的对角化矩阵为：\n",A.diagonalize()) 7 | else: print("A不能对角化") 8 | P=A.diagonalize()[0]; D=A.diagonalize()[1] 9 | x=P*D**n*(P.inv())*sp.Matrix([a0,b0,c0]) 10 | x=sp.simplify(x); print(x) 11 | 12 | 13 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pex13_7_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex13_7_2.py 2 | import sympy as sp 3 | a0,b0, c0=sp.symbols('a0 b0 c0') 4 | n=sp.symbols('n',positive=True) 5 | A=sp.Matrix([[1,1/4,0],[0,1/2,0],[0,1/4,1]]) 6 | if A.is_diagonalizable(): print("A的对角化矩阵为：\n",A.diagonalize()) 7 | else: print("A不能对角化") 8 | P=A.diagonalize()[0]; D=A.diagonalize()[1] 9 | x=P*D**n*(P.inv())*sp.Matrix([a0,b0,c0]) 10 | x=sp.simplify(x); print(x) 11 | 12 | 13 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/Pz13_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz13_1.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | plt.rc('text',usetex=True); plt.rc('font',size=16) 5 | logistic=lambda k, x: k*x*(1-x) 6 | kk=np.arange(0, 4.01, 0.01); listk=[]; listx=[] 7 | for k in kk: 8 | x=0.5 9 | for i in range(1,500): 10 | x1=logistic(k,x); x=x1 11 | if i>400: listk.append(k); listx.append(x) 12 | plt.scatter(listk,listx,c='b',s=1); plt.grid(True) 13 | plt.xticks(np.arange(0,4.01,0.5)); plt.xlabel("$k$") 14 | plt.ylabel("$x^*(k)$"); plt.show() 15 | -------------------------------------------------------------------------------- /13第13章 差分方程模型/figure13_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/13第13章 差分方程模型/figure13_1.png -------------------------------------------------------------------------------- /13第13章 差分方程模型/figure13_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/13第13章 差分方程模型/figure13_2.png -------------------------------------------------------------------------------- /13第13章 差分方程模型/figure13_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/13第13章 差分方程模型/figure13_3.png -------------------------------------------------------------------------------- /13第13章 差分方程模型/figure13_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/13第13章 差分方程模型/figure13_4.png -------------------------------------------------------------------------------- /13第13章 差分方程模型/figure13_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/13第13章 差分方程模型/figure13_5.png -------------------------------------------------------------------------------- /14第14章 模糊数学/Pdata14_12.txt: -------------------------------------------------------------------------------- 1 | 592.5 3 55 72 5 2 | 529 2 38 105 3 3 | 412 1 32 85 2 4 | -------------------------------------------------------------------------------- /14第14章 模糊数学/Pex14_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex14_10.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from skfuzzy.cluster import cmeans 5 | a=np.array([[1,3],[1.5,3.2],[1.3,2.8],[3,1]]) 6 | cntr,u, _, _, _, _, _ = cmeans(a.T,c=2,m=2,error=0.005, maxiter=1000) 7 | #cntr的每一行是一个聚类中心，u的每一列是一个对象的隶属度 8 | print(cntr,'\n-------------------------\n',u) 9 | 10 | -------------------------------------------------------------------------------- /14第14章 模糊数学/Pex14_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex14_11.py 2 | import numpy as np 3 | d=np.array([[4,2,1,0,0],[6,1,0,0,0],[0,0,5,1,1],[2,2,1,1,1]]) 4 | r=d/7; w1=np.array([0.2,0.5,0.1,0.2]) 5 | w2=np.array([0.2,0.1,0.5,0.2]) 6 | a1=np.dot(w1,r); a2=np.dot(w2,r) 7 | print(a1,'\n---------------------------------------\n',a2) 8 | -------------------------------------------------------------------------------- /14第14章 模糊数学/Pex14_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex14_12.py 2 | from numpy import array, piecewise, c_ 3 | d=array([[592.5,3,55,72,5],[529,2,38,105,3],[412,1,32,85,2]]); d=d.T 4 | c1=lambda x: piecewise(x, [(350=600], [lambda x:(x-350)/250., 1]) 5 | c2=lambda x: piecewise(x, [(1.0=130], [lambda x:(x-50)/80., 1]) 8 | c5=lambda x: piecewise(x, [(10.2) & (a<=0.5)); n3=np.sum(a>0.5) 6 | f=np.array([n1,n2,n3])/n; print(f) 7 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_10 2 | from numpy.random import exponential, uniform, seed 3 | from numpy import mean, array, zeros 4 | seed(4) #进行一致性比较,每次运行结果一样 5 | def oneday(): 6 | W=[0] #第一个顾客的等待时间 7 | t0=exponential(10); c0=t0 8 | g0=c0+uniform(4,15); g=g0 9 | while g<480: 10 | t=exponential(10) #下一个到达时间间隔 11 | c=c0+t #下一个到达时刻 12 | w=max(0,g-c) #下一个等待时间 13 | g=max(g,c)+uniform(4,15) #下一个离开时刻 14 | c0=c #把当前到达时刻保存起来 15 | W.append(w) #把等待时间保存到列表中 16 | return len(W), mean(W) 17 | W1=oneday(); print("服务人数和平均等待时间分别为：",W1) 18 | d=1000 #模拟的天数 19 | T=zeros(d); N=zeros(d) 20 | for i in range(d): 21 | N[i],T[i]=oneday() 22 | print("平均服务人数为：",round(N.mean())) 23 | print("平均等待时间为：",T.mean()) 24 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_11 2 | import numpy as np 3 | N=100000; mu=[0.1, 0.3, 0.1, 0.1, 1.5, 16, 0.75] 4 | cov=np.diag([(0.005/3)**2,0.005**2,(0.005/3)**2, 5 | (0.01/3)**2, 0.05**2, (0.8/3)**2, 0.0125**2]) 6 | a=np.random.multivariate_normal(mu,cov,size=N) 7 | x1,x2,x3,x4,x5,x6,x7 = a.T 8 | y=174.42*x1/x5*(x3/(x2-x1))**0.85*np.sqrt((1-2.62*(1-0.36* 9 | (x4/x2)**(-0.56))**(3/2)*(x4/x2)**1.16)/(x6*x7)) 10 | d=np.abs(y-1.5) 11 | f=np.sum(9000*(d>=0.3)+1000*((d<0.3)&(d>=0.1)))/N 12 | print("平均损失为：",f) 13 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_2.py 2 | from numpy.random import rand 3 | import numpy as np 4 | n=10000; a=rand(n); 5 | p=np.array([0.2,0.05,0.01,0.06,0.08,0.1,0.3,0.05,0.03,0.12]) 6 | cp=np.cumsum(p); c=[]; c.append(np.sum(a<=cp[0])) 7 | for i in range(1,len(p)): 8 | c.append(np.sum((a>cp[i-1]) & (a<=cp[i]))) 9 | print(c) 10 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_4.py 2 | from numpy.random import uniform 3 | import numpy as np 4 | N=10000000; x=uniform(-1,1,size=N) 5 | y=uniform(-1,1,N); z=uniform(0,1,N) 6 | n=np.sum((x**2+y**2<=1) & (z>=0) & (z<=np.sqrt(1-x**2))) 7 | I=n/N*4; print("I的近似值为：",I) 8 | 9 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_5.py 2 | from numpy.random import rand 3 | import numpy as np 4 | N=1000000; x=rand(N); y=rand(N) 5 | n=np.sum(x**2+y**2<1) 6 | s=4*n/N; print(s) 7 | 8 | 9 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_6.py 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | plt.rc('font',size=16); N=10000; 5 | x,y=np.random.uniform(-1,1,size=(2,N)) 6 | inside=(x**2+y**2)<=1 7 | mpi=inside.sum()*4/N #求pi的近似值 8 | error=abs((mpi-np.pi)/np.pi)*100 9 | outside=np.invert(inside) 10 | plt.plot(x[inside],y[inside],'b.') 11 | plt.plot(x[outside],y[outside],'r.') 12 | plt.plot(0,0,label='$\hat\pi$={:4.3f}\nerror={:4.3f}%'. 13 | format(mpi,error),alpha=0) 14 | plt.axis('square'); plt.legend(); plt.show() 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_7.py 2 | import numpy as np 3 | from scipy.integrate import dblquad 4 | fxy=lambda x,y: 1/(20000*np.pi)*np.exp(-(x**2+y**2)/20000) 5 | bdy=lambda x: 80*np.sqrt(1-x**2/120**2) 6 | p1=dblquad(fxy,-120,120,lambda x:-bdy(x),bdy) 7 | print("概率的数值解为：",p1) 8 | N=1000000; mu=[0,0]; cov=10000*np.identity(2); 9 | a=np.random.multivariate_normal(mu,cov,size=N) 10 | n=((a[:,0]**2/120**2+a[:,1]**2/80**2)<=1).sum() 11 | p2=n/N; print('概率的近似值为：',p2) 12 | 13 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_8.py 2 | import numpy as np 3 | from matplotlib.pyplot import rc, plot, show 4 | from scipy.optimize import fminbound, fmin 5 | rc('font',size=16) 6 | fx=lambda x:(1-x**3)*np.sin(3*x); 7 | x0=np.linspace(-2*np.pi,2*np.pi,100); 8 | y0=fx(x0); plot(x0,y0); show() 9 | xm1=fminbound(lambda x:-fx(x),-2*np.pi,2*np.pi) 10 | ym1=fx(xm1); print(xm1,ym1,'\n--------------') 11 | xm2=fmin(lambda x:-fx(x), -2*np.pi) 12 | ym2=fx(xm2); print(xm2,ym2,'\n--------------') 13 | x=np.random.uniform(-2*np.pi,2*np.pi,100) 14 | y=fx(x); ym=y.max() 15 | xm=x[y==ym]; print(xm,ym) 16 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_9_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_9_1.py 2 | from scipy.stats import poisson 3 | a=2; b=3; lamda=10; p=1-a/b 4 | u=poisson.ppf(1-a/b,lamda) #求最佳订购量 5 | p1=poisson.cdf(u-1,lamda) #p1和p2是为验证最佳购进量 6 | p2=poisson.cdf(u,lamda) 7 | print(u,p1,p,p2) 8 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/Pex16_9_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex16_9_2.py 2 | import numpy as np 3 | a=2; b=3; lamda=10; M1=0; 4 | u=1; n=10000; 5 | for i in range(1,2*lamda): 6 | d=np.random.poisson(lamda,n) #产生n个服从Poiss分布的需求量数据 7 | M2=np.mean(((b-a)*u*(u<=d)+((b-a)*d-a*(u-d))*(u>d))) #求平均利润 8 | if M2>M1: M1=M2; u=u+1; 9 | else: print('最佳购进量:',u-1); break 10 | 11 | 12 | -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/figure16_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/16第16章 Monte Carlo模拟/figure16_2.png -------------------------------------------------------------------------------- /16第16章 Monte Carlo模拟/figure16_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/16第16章 Monte Carlo模拟/figure16_3.png -------------------------------------------------------------------------------- /17第17章 智能算法/Pdata17_5.txt: -------------------------------------------------------------------------------- 1 | 20.55 0.6 0.09 5126 1237 2 | 22.44 0.75 0.11 6217 1379 3 | 25.37 0.85 0.11 7730 1385 4 | 27.13 0.9 0.14 9145 1399 5 | 29.45 1.05 0.2 10460 1663 6 | 30.1 1.35 0.23 11387 1714 7 | 30.96 1.45 0.23 12353 1834 8 | 34.06 1.6 0.32 15750 4322 9 | 36.42 1.7 0.32 18304 8132 10 | 38.09 1.85 0.34 19836 8936 11 | 39.13 2.15 0.36 21024 11099 12 | 39.99 2.2 0.36 19490 11203 13 | 41.93 2.25 0.38 20433 10524 14 | 44.59 2.35 0.49 22598 11115 15 | 47.3 2.5 0.56 25107 13320 16 | 52.89 2.6 0.59 33442 16762 17 | 55.73 2.7 0.59 36836 18673 18 | 56.76 2.85 0.67 40548 20724 19 | 59.17 2.95 0.69 42927 20803 20 | 60.63 3.1 0.79 43462 21804 21 | -------------------------------------------------------------------------------- /17第17章 智能算法/Pex17_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex17_3.py 2 | from sklearn.linear_model import Perceptron 3 | import numpy as np 4 | x0=np.array([[-0.5,-0.5,0.3,0.0],[-0.5,0.5,-0.5,1.0]]).T 5 | y0=np.array([1,1,0,0]) 6 | md = Perceptron(tol=1e-3) #构造模型 7 | md.fit(x0, y0) #拟合模型 8 | print(md.coef_,md.intercept_) #输出系数和常数项 9 | print(md.score(x0,y0)) #模型检验 10 | print("预测值为：",md.predict(np.array([[-0.5,0.2]]))) 11 | -------------------------------------------------------------------------------- /17第17章 智能算法/Pex17_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex17_4.py 2 | from sklearn.neural_network import MLPClassifier 3 | from numpy import array, r_, ones,zeros 4 | x0=array([[1.14,1.18,1.20,1.26,1.28,1.30,1.24,1.36,1.38,1.38,1.38,1.40,1.48,1.54,1.56], 5 | [1.78,1.96,1.86,2.00,2.00,1.96,1.72,1.74,1.64,1.82,1.90,1.70,1.82,1.82,2.08]]).T 6 | y0=r_[ones(6),zeros(9)] 7 | md = MLPClassifier(solver='lbfgs', alpha=1e-5, 8 | hidden_layer_sizes=15) 9 | md.fit(x0, y0); x=array([[1.24, 1.80], [1.28, 1.84], [1.40, 2.04]]) 10 | pred=md.predict(x); print(md.score(x0,y0)); print(md.coefs_) 11 | print("属于各类的概率为：",md.predict_proba(x)) 12 | print("三个待判样本点的类别为：",pred); 13 | -------------------------------------------------------------------------------- /17第17章 智能算法/figure17_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/17第17章 智能算法/figure17_1.png -------------------------------------------------------------------------------- /17第17章 智能算法/figure17_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/17第17章 智能算法/figure17_2.png -------------------------------------------------------------------------------- /17第17章 智能算法/figure17_2_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/17第17章 智能算法/figure17_2_2.png -------------------------------------------------------------------------------- /17第17章 智能算法/figure17_2_2_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/17第17章 智能算法/figure17_2_2_3.png -------------------------------------------------------------------------------- /17第17章 智能算法/figure17_2_2_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/17第17章 智能算法/figure17_2_2_4.png -------------------------------------------------------------------------------- /17第17章 智能算法/figure17_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/17第17章 智能算法/figure17_5.png -------------------------------------------------------------------------------- /17第17章 智能算法/game.py: -------------------------------------------------------------------------------- 1 | #程序文件game.py 2 | import numpy as np 3 | import numpy.random as nr 4 | a=[1,2,3,4,5,6]*4 #构造列表 5 | b=np.array(a) #转换为数组 6 | nr.shuffle(b) #打乱数组b 7 | s1=0; s2=0; n=0; 8 | while s1<31 and s2<31 and len(b)>0: 9 | ind1=nr.randint(0,len(b)) #产生一个随机整数 10 | s1+=b[ind1]; np.delete(b,ind1) #第一个人加点，并删除对应的元素 11 | n+=1; ind2=nr.randint(0,len(b)) #产生随机整数 12 | s2+=b[ind2]; np.delete(b,ind2); n+=1; 13 | if s1==31 or s2>31: print("The first person win!"); break 14 | if s2==31 or s1>31: print("The second person win!"); break 15 | else: 16 | if n%2==0: print("The second person win!") 17 | else: print("The first person win!") 18 | 19 | 20 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pdata18_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/Pdata18_2.xlsx -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pdata18_3.txt: -------------------------------------------------------------------------------- 1 | 2031 2 | 2234 3 | 2566 4 | 2820 5 | 3006 6 | 3093 7 | 3277 8 | 3514 9 | 3770 10 | 4107 11 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pdata18_3.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/Pdata18_3.xlsx -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pdata18_4.txt: -------------------------------------------------------------------------------- 1 | 265 373 333 266 2 | 251 379 374 309 3 | 272 437 396 348 4 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_1_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_1_1.py 2 | import numpy as np 3 | y=np.array([423,358,434,445,527,429,426,502,480,384,427,446]) 4 | def MoveAverage(y,N): 5 | Mt=['*']*N 6 | for i in range(N+1,len(y)+2): 7 | M=y[i-(N+1):i-1].mean() 8 | Mt.append(M) 9 | return Mt 10 | yt3=MoveAverage(y,3) 11 | s3=np.sqrt(((y[3:]-yt3[3:-1])**2).mean()) 12 | yt5=MoveAverage(y,5) 13 | s5=np.sqrt(((y[5:]-yt5[5:-1])**2).mean()) 14 | print('N=3时,预测值：',yt3,'，预测的标准误差：',s3) 15 | print('N=5时,预测值：',yt5,'，预测的标准误差：',s5) 16 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_1_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_1_2.py 2 | import numpy as np 3 | y=np.array([423,358,434,445,527,429,426,502,480,384,427,446]) 4 | n1=3; yt1=np.convolve(np.ones(n1)/n1,y)[n1-1:-n1+1] 5 | s1=np.sqrt(((y[n1:]-yt1[:-1])**2).mean()) 6 | n2=5; yt2=np.convolve(np.ones(n2)/n2,y)[n2-1:-n2+1] 7 | s2=np.sqrt(((y[n2:]-yt2[:-1])**2).mean()) 8 | print('N=3时,预测值：',yt1,'，预测的标准误差：',s1) 9 | print('N=5时,预测值：',yt2,'，预测的标准误差：',s2) 10 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_2.py 2 | import numpy as np 3 | import pandas as pd 4 | y=np.array([4.81,4.8,4.73,4.7,4.7,4.73,4.75,4.75,5.43,5.78,5.85]) 5 | def ExpMove(y,a): 6 | n=len(y); M=np.zeros(n); M[0]=(y[0]+y[1])/2; 7 | for i in range(1,len(y)): 8 | M[i]=a*y[i-1]+(1-a)*M[i-1] 9 | return M 10 | yt1=ExpMove(y,0.2); yt2=ExpMove(y,0.5) 11 | yt3=ExpMove(y,0.8); s1=np.sqrt(((y-yt1)**2).mean()) 12 | s2=np.sqrt(((y-yt2)**2).mean()) 13 | s3=np.sqrt(((y-yt3)**2).mean()) 14 | d=pd.DataFrame(np.c_[yt1,yt2,yt3]) 15 | f=pd.ExcelWriter("Pdata18_2.xlsx"); 16 | d.to_excel(f); f.close() #数据写入Excel文件，便于做表 17 | print("预测的标准误差分别为：",s1,s2,s3) #输出预测的标准误差 18 | yh=0.8*y[-1]+0.2*yt3[-1] 19 | print("下一期的预测值为：",yh) 20 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_3.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_3 2 | import numpy as np 3 | import pandas as pd 4 | y=np.loadtxt('Pdata18_3.txt') 5 | n=len(y); alpha=0.3; yh=np.zeros(n) 6 | s1=np.zeros(n); s2=np.zeros(n) 7 | s1[0]=y[0]; s2[0]=y[0] 8 | for i in range(1,n): 9 | s1[i]=alpha*y[i]+(1-alpha)*s1[i-1] 10 | s2[i]=alpha*s1[i]+(1-alpha)*s2[i-1]; 11 | yh[i]=2*s1[i-1]-s2[i-1]+alpha/(1-alpha)*(s1[i-1]-s2[i-1]) 12 | at=2*s1[-1]-s2[-1]; bt=alpha/(1-alpha)*(s1[-1]-s2[-1]) 13 | m=np.array([1,2]) 14 | yh2=at+bt*m 15 | print("预测值为：",yh2) 16 | d=pd.DataFrame(np.c_[s1,s2,yh]) 17 | f=pd.ExcelWriter("Pdata18_3.xlsx"); 18 | d.to_excel(f); f.close() 19 | 20 | 21 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_4 2 | import numpy as np 3 | a=np.loadtxt('Pdata18_4.txt') 4 | m,n=a.shape 5 | amean=a.mean() #计算所有数据的平均值 6 | cmean=a.mean(axis=0) #逐列求均值 7 | r=cmean/amean #计算季节系数 8 | w=np.arange(1,m+1) 9 | yh=w.dot(a.sum(axis=1))/w.sum() #计算下一年的预测值 10 | yj=yh/n #计算预测年份的季度平均值 11 | yjh=yj*r #计算季度预测值 12 | print("下一年度各季度的预测值为：",yjh) 13 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_5_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_5_1.py 2 | import pandas as pd, numpy as np 3 | import statsmodels.api as sm 4 | import matplotlib.pyplot as plt 5 | plt.rc('font',family='SimHei'); plt.rc('font',size=16) 6 | d=pd.read_csv('sunspots.csv',usecols=['counts']) 7 | md=sm.tsa.ARMA(d,(9,1)).fit() 8 | years=np.arange(1700,1989) #已知观测值的年代 9 | dhat=md.predict() 10 | plt.plot(years[-20:],d.values[-20:],'o-k') 11 | plt.plot(years[-20:],dhat.values[-20:],'P--') 12 | plt.legend(('原始观测值','预测值')); plt.show() 13 | dnext=md.predict(d.shape[0],d.shape[0]) 14 | print(dnext) #显示下一期的预测值 15 | 16 | 17 | 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/Pex18_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex18_6.py 2 | import pandas as pd 3 | from statsmodels.graphics.tsaplots import plot_acf 4 | import pylab as plt 5 | from statsmodels.tsa.arima_model import ARIMA 6 | 7 | plt.rc('axes',unicode_minus=False) 8 | plt.rc('font',size=16); plt.rc('font',family='SimHei') 9 | df=pd.read_csv('austa.csv') 10 | plt.subplot(121); plt.plot(df.value.diff()) 11 | plt.title('一次差分') 12 | ax2=plt.subplot(122) 13 | plot_acf(df.value.diff().dropna(), ax=ax2,title='自相关') 14 | 15 | md=ARIMA(df.value, order=(2,1,0)) 16 | mdf=md.fit(disp=0) 17 | print(mdf.summary()) 18 | 19 | residuals = pd.DataFrame(mdf.resid) 20 | fig, ax = plt.subplots(1,2) 21 | residuals.plot(title="残差", ax=ax[0]) 22 | residuals.plot(kind='kde', title='密度', ax=ax[1]) 23 | plt.legend(''); plt.ylabel('') 24 | 25 | mdf.plot_predict() #原始数据与预测值对比图 26 | plt.show() 27 | 28 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/austa.csv: -------------------------------------------------------------------------------- 1 | "date","value" 2 | 1980-01-01,0.82989428 3 | 1981-01-01,0.85951092 4 | 1982-01-01,0.87668916 5 | 1983-01-01,0.86670716 6 | 1984-01-01,0.932052 7 | 1985-01-01,1.04826364 8 | 1986-01-01,1.3111932 9 | 1987-01-01,1.63756228 10 | 1988-01-01,2.0641074 11 | 1989-01-01,1.91268276 12 | 1990-01-01,2.03544572 13 | 1991-01-01,2.17721128 14 | 1992-01-01,2.38968344 15 | 1993-01-01,2.75059208 16 | 1994-01-01,3.0906664 17 | 1995-01-01,3.42664028 18 | 1996-01-01,3.83064908 19 | 1997-01-01,3.97190864 20 | 1998-01-01,3.83160036 21 | 1999-01-01,4.143101 22 | 2000-01-01,4.566551 23 | 2001-01-01,4.47541 24 | 2002-01-01,4.462796 25 | 2003-01-01,4.384829 26 | 2004-01-01,4.796861 27 | 2005-01-01,5.046211 28 | 2006-01-01,5.098759 29 | 2007-01-01,5.196519 30 | 2008-01-01,5.166843 31 | 2009-01-01,5.174744 32 | 2010-01-01,5.440894 -------------------------------------------------------------------------------- /18第18章 时间序列分析/fadian.txt: -------------------------------------------------------------------------------- 1 | 676 2 | 825 3 | 774 4 | 716 5 | 940 6 | 1159 7 | 1384 8 | 1524 9 | 1668 10 | 1688 11 | 1958 12 | 2031 13 | 2234 14 | 2566 15 | 2820 16 | 3006 17 | 3093 18 | 3277 19 | 3514 20 | 3770 21 | 4107 22 | -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_1.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_2.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_3.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_4.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_4_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_4_2.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_4_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_4_3.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_5.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_6.png -------------------------------------------------------------------------------- /18第18章 时间序列分析/figure18_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/18第18章 时间序列分析/figure18_7.png -------------------------------------------------------------------------------- /19第19章 支持向量机/Pex19_1_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex19_1.py 2 | from sklearn import datasets, svm, metrics 3 | from sklearn.model_selection import GridSearchCV 4 | import numpy as np 5 | iris=datasets.load_iris() 6 | x=iris.data; y=iris.target 7 | parameters = {'kernel':('linear','rbf'), 'C':[1,10,15]} 8 | svc=svm.SVC(gamma='scale') 9 | clf=GridSearchCV(svc,parameters,cv=5) #cv为交叉验证参数，为5折 10 | clf.fit(x,y) 11 | print("最佳的参数值:", clf.best_params_) 12 | print("score：",clf.score(x,y)) 13 | yh=clf.predict(x); print(yh) #显示分类的结果 14 | print("预测准确率：",metrics.accuracy_score(y,yh)) 15 | print("误判的样本点为:",np.where(yh!=y)[0]+1) 16 | -------------------------------------------------------------------------------- /19第19章 支持向量机/Pex19_1_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex19_1_2.py 2 | from sklearn import datasets, svm 3 | from sklearn.model_selection import GridSearchCV 4 | import numpy as np 5 | iris=datasets.load_iris() 6 | x=iris.data; y=iris.target 7 | clf=svm.LinearSVC(C=1,max_iter=10000) 8 | clf.fit(x,y); yh=clf.predict(x); print(yh) 9 | print("预测的准确率：",clf.score(x,y)) 10 | -------------------------------------------------------------------------------- /19第19章 支持向量机/Pex19_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex19_2.py 2 | import numpy as np 3 | import pylab as plt 4 | from sklearn.svm import SVR 5 | 6 | np.random.seed(123) 7 | x=np.arange(200).reshape(-1,1) 8 | y=(np.sin(x)+3+np.random.uniform(-1,1,(200,1))).ravel() 9 | 10 | model = SVR(gamma='auto'); print(model) 11 | model.fit(x,y); pred_y = model.predict(x) 12 | print("原始数据与预测值前15个值对比：") 13 | for i in range(15): print(y[i],pred_y[i]) 14 | 15 | plt.rc('font',family='SimHei'); plt.rc('font',size=15) 16 | plt.scatter(x, y, s=5, color="blue", label="原始数据") 17 | plt.plot(x, pred_y, '-r*',lw=1.5, label="预测值") 18 | plt.legend(loc=1) 19 | 20 | score=model.score(x,y); print("score:",score) 21 | ss=((y-pred_y)**2).sum() #计算残差平方和 22 | print("残差平方和：", ss) 23 | plt.show() 24 | 25 | 26 | -------------------------------------------------------------------------------- /19第19章 支持向量机/figure19_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/19第19章 支持向量机/figure19_1.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/Lena.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/Lena.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/Lena.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/Lena.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_1.py 2 | import cv2 3 | img=cv2.imread("Lena.bmp") 4 | cv2.imshow('image',img) 5 | cv2.imwrite('Lena.jpg',img) 6 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_10.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_10.py 2 | from PIL import Image 3 | a=Image.open('flower.jpg') #读入图像 4 | b=Image.open('logo.jpg') 5 | print(a.size,b.size) #显示图像的大小 6 | c=b.resize((50,50)) #把图像缩小 7 | a.paste(c,(20,20)); a.show() #粘贴图像并显示 8 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_11.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_11.py 2 | from PIL import Image 3 | from numpy import array 4 | a=Image.open('flower.jpg') #读入图像 5 | position=(100,100); b1=a.getpixel(position) #读取像素 6 | a.putpixel(position,tuple(array(b1)//2)) #修改像素 7 | print(b1,a.getpixel(position)) #显示修改前后的像素值 8 | 9 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_12.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_12.py 2 | from PIL import Image,ImageDraw 3 | from numpy import array 4 | a=Image.open('flower.jpg') #读入图像 5 | w,h=a.size #读入图像的宽度和高度 6 | b=ImageDraw.Draw(a) #实例化Draw类 7 | b.line(((0,0),(w-1,h-1)),fill=(255,0,0)) 8 | b.line(((w-1,0),(0,h-1)),fill=(255,0,0)) 9 | b.arc((0,0,w-1,h-1),0,360,fill=(255,0,0)) 10 | a.show(); a.save("figure20_12.png") #显示并保存图像 11 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_13.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_13.py 2 | from PIL import Image,ImageDraw, ImageFont 3 | a=Image.open('flower.jpg') #读入图像 4 | b=ImageDraw.Draw(a) #实例化Draw类 5 | myfont=ImageFont.truetype("c:\\Windows\\Fonts\\simsun.ttc",48) 6 | b.text((20,20),"美丽的花",font=myfont,fill=(255,0,0)) 7 | a.show(); a.save("figure20_13.png") 8 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_14.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_14.py 2 | from PIL import Image,ImageFilter 3 | from pylab import subplot, show, imshow 4 | a=Image.open('flower.jpg') #读入图像 5 | b=a.filter(ImageFilter.CONTOUR) #使用轮廓滤镜 6 | subplot(121); imshow(a) 7 | subplot(122); imshow(b); show() 8 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_16.py: -------------------------------------------------------------------------------- 1 | # 程序文件Pex20_16.py 2 | from PIL import Image, ImageFont, ImageDraw 3 | 4 | a = Image.open("玉龙雪山.jpg").convert("RGBA") 5 | b = Image.new("RGBA", a.size, (0, 0, 0, 0)) # (0,0,0,0)透明 6 | fnt = ImageFont.truetype("simsun.ttc", 120) # 设置字体 7 | c = ImageDraw.Draw(b) # 将新建的图像添入画板 8 | c.text( 9 | (b.size[0] - 500, b.size[1] - 150), "玉龙雪山", font=fnt, fill=(255, 255, 255, 255) 10 | ) # (255,255,255,255)为白色，不透明 11 | d = Image.alpha_composite(a, b) # 合并两个图像 12 | d.show() 13 | d.save("figure20_16.png") 14 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_17.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_17.py 2 | from PIL import Image 3 | base=Image.open("flower.jpg").convert("RGBA") 4 | watermark=Image.open("logo.jpg").convert("RGBA").resize((100,100)) 5 | width,height=base.size 6 | mark_width,mark_height=watermark.size 7 | position=(width-mark_width,height-mark_height) 8 | transparent=Image.new('RGBA',(width, height),(0,0,0,0)) 9 | transparent.paste(base,(0,0)) 10 | transparent.paste(watermark,position,mask=watermark) 11 | transparent.show() 12 | transparent.save("figure20_17.png") 13 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_18.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_18.py 2 | import qrcode 3 | qr=qrcode.QRCode( 4 | version=1, #二维码的尺寸大小，取值范围为1-40 5 | error_correction=qrcode.constants.ERROR_CORRECT_L, 6 | box_size=10, #二维码里每个格子的像素大小 7 | border=5 #边框的格子厚度，默认是4 8 | ) 9 | qr.add_data("https://www.python.org/") #设置二维码数据 10 | qr.make(fit=True) #启用二维码颜色设置 11 | img=qr.make_image(fill_color="green", back_color="white") 12 | img.show(); img.save("figure20_17.png") #显示并保存二维码 13 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_19.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_19.py 2 | from PIL import Image 3 | import qrcode 4 | qr=qrcode.QRCode( 5 | version=2, 6 | error_correction=qrcode.constants.ERROR_CORRECT_H, 7 | box_size=10, 8 | border=1 9 | ) 10 | qr.add_data("https://www.python.org/") 11 | qr.make(fit=True) 12 | img=qr.make_image().convert("RGBA") 13 | w1,h1=img.size 14 | factor=4; w2=w1//factor; h2=h1//factor 15 | 16 | icon=Image.open("logo.jpg") 17 | w3,h3=icon.size 18 | if w3>w2: w3=w2 19 | if h3>w2: h3=h2 20 | icon=icon.resize((w3,h3)) #更改图标的尺寸 21 | w4=(w1-w3)//2; h4=(h1-h3)//2 22 | img.paste(icon,(w4,h4)) #将图标粘贴到二维码的中心位置 23 | img.show(); img.save("figure20_19.png") 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_2.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_2.py 2 | import cv2,os 3 | os.mkdir("source") #在当前目录下创建新目录source 4 | video=cv2.VideoCapture("test.avi") 5 | L=int(video.get(cv2.CAP_PROP_FRAME_COUNT)) #计算视频的帧数 6 | for i in range(L-1): 7 | ret,frame=video.read() 8 | cv2.imshow('Frame',frame); cv2.waitKey(2) #停顿2毫秒 9 | cv2.imwrite("source\\"+str(i)+".jpg",frame) 10 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_4.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_4.py 2 | from PIL import Image 3 | from numpy import array 4 | import pylab as plt #加载Matplotlib的Pylab接口 5 | a=Image.open("empire.jpg") #返回一个PIL图像对象 6 | b=a.convert("L") #转换为灰度图像对象 7 | b.save("empire2.jpg") #把灰度图像保存到empire2.jpg 8 | aa=array(a) #把图像对象转换为数组 9 | print(aa.shape) #显示图像的大小 10 | #左上角为坐标原点，下面裁剪左上右下指定区域 11 | c=a.crop((100,100,400,400)) 12 | d=a.rotate(45) #图像旋转45度 13 | plt.rc('font',family="SimHei") 14 | plt.subplot(221); plt.imshow(a); plt.title("原图") 15 | plt.subplot(222); plt.imshow(b); plt.title("灰度图") 16 | plt.subplot(223); plt.imshow(c); plt.title("剪裁图像") 17 | plt.subplot(224); plt.imshow(d); plt.title("旋转图像"); plt.show() 18 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_5.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_5.py 2 | from PIL import Image 3 | from numpy import array 4 | import pylab as plt #加载Matplotlib的Pylab接口 5 | #下面读取图像到数组中 6 | a=array(Image.open("empire.jpg").convert('L')) 7 | plt.rc('font',size=16) 8 | plt.subplot(121); plt.contour(a,origin='image') #轮廓图 9 | plt.subplot(122); plt.hist(a.flatten(),128); plt.show() 10 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_6.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_6.py 2 | from PIL import Image 3 | a=Image.open('flower.jpg') #读入图像 4 | a.show() #显示图片 5 | print(a.mode, a.size, a.format) #显示图片信息 6 | a.save("flower2.png") #另存为另一文件 7 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_7.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_7.py 2 | from PIL import Image 3 | a=Image.new("RGB",(640,480),(50,50,100,0)) #创建新图像 4 | a.save("figure20_7.jpg") #保存图像 5 | a.show() #显示图像 6 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_8.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_8.py 2 | from PIL import Image 3 | from pylab import subplot,imshow,show 4 | a=Image.open('flower.jpg') #读入图像 5 | b=a.resize((128,128)) #改变图像尺寸 6 | c=b.convert('CMYK') #转换为CMYK模式 7 | subplot(121); imshow(b) 8 | subplot(122); imshow(c); show() 9 | 10 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pex20_9.py: -------------------------------------------------------------------------------- 1 | #程序文件Pex20_8.py 2 | from PIL import Image 3 | from pylab import subplot,imshow,show 4 | a=Image.open('flower.jpg') #读入图像 5 | ra,ga,ba=a.split() #图像分割成R、G、B三个通道 6 | c=Image.merge('RGB',(ra,ga,ba)) #三个通道合成一张彩色图像 7 | subplot(221); imshow(ra); subplot(222); imshow(ga) 8 | subplot(223); imshow(ba); subplot(224); imshow(c); show() 9 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/Pz20_1.py: -------------------------------------------------------------------------------- 1 | #程序文件Pz20_1.py 2 | import cv2 3 | flags = [i for i in dir(cv2) if i.startswith('COLOR_')] 4 | print(flags) 5 | -------------------------------------------------------------------------------- /20第20章 数字图像处理/empire.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/empire.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/empire2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/empire2.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_12.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_13.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_13.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_15.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_15.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_16.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_17.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_17.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_19.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_19.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_2.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/figure20_7.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/figure20_7.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/flower.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/flower.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/flower2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/flower2.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/logo.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/peppers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/peppers.png -------------------------------------------------------------------------------- /20第20章 数字图像处理/simsunb.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/simsunb.ttf -------------------------------------------------------------------------------- /20第20章 数字图像处理/test.avi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/test.avi -------------------------------------------------------------------------------- /20第20章 数字图像处理/玉龙雪山.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/玉龙雪山.jpg -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/000.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/000.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/001.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/001.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/002.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/002.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/003.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/003.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/004.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/004.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/005.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/005.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/006.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/006.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/007.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/007.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/008.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/008.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/009.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/009.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/010.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/010.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/011.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/011.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/012.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/012.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/013.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/013.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/014.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/014.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/015.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/015.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/016.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/016.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/017.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/017.bmp -------------------------------------------------------------------------------- /20第20章 数字图像处理/附件1/018.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/20第20章 数字图像处理/附件1/018.bmp -------------------------------------------------------------------------------- /说明.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/liyiliuxingyu/Python-MEM-PD/5d0e9f779ea956d529bce1bb4f63ed208db81b52/说明.txt --------------------------------------------------------------------------------