[同济大学python程序设计笔记]

一、基本语法与元素

二、数据结构

三、结构化程序设计

四、函数

五、文件和数据格式化

六面向对象

七数据可视化

八、第三方库

1 turtle库

2 random库

3 time库

4 pyinstaller库和jieba库

5 常见的第三方库

一、基本语法与元素

1 程序与程序设计语言

计算机程序：
- 计算机程序是为了解决某个特定问题
- 使用某种程序设计语言编写的一组指令序列
程序的IPO模式
- 数据输入
- 数据处理
- 数据输出

程序设计语言分类

低级语言
- 机器语言
  - 由0和1组成的能被机器直接理解和执行的指令集合
- 汇编语言
  - 用英文助记符来表示机器指令
高级语言————面向自然语言和数学语言，远离机器的程序设计语言
- 面向过程程序设计语言
- 面向对象程序设计语言
解释性语言
- python、VB.NET
编译性语言
- C/C++、C#

安装第三方库

pip install wordcloud -i https://mirrors.aliyun.com/pypi/simple/
pip install scipy -i https://mirrors.aliyun.com/pypi/simple/

生成可执行文件

pyinstaller  选项  Python源文件
-F 生成单个可执行文件
-D 产生一个目录
-d 产生debug版本的可执行文件
-w 指定程序运行时不显示命令行窗口

2 关键字

'False', 'None', 'True', 'peg_parser', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

assert:检测调试代码
is:判断两个变量的指向是否完全一致，及内容与地址需要完全一致，才返回True，否则返回False
raise:主动抛异常设定的关键字
yield:任何使用yield的函数都称之为生成器，而生成器通常可理解成迭代器
async:异步编程
await:异步编程

二、数据结构

1 数据类型分类

基本数据类型
- 整数 int
- 浮点数 float
- 复数 complex
- 布尔型 bool
复合数据类型
- 有序序列
  - 字符串型 str
  - 列表 list
  - 元组 tuple
- 无序序列
  - 字典 dict
  - 集合 set
常量
- 表示固定不变的数据
变量
- 用来存储可能变化的数据
标识符
- 在程序中为处理的对象起个名字
  - 3xy # 数字开头
  - y-z # 不允许出现减号运算符
  - Wang Ping # 不允许出现空格
  - False # Python中的关键字
  - Sin # Python中的函数名

2 数字类型

包括int（整数类形）、float（浮点数类型）、complex（复数类型）和bool（布尔型，数字里面的布尔型不是指True和False，指的是1和0）。

整数
- 十进制
  - n n:0-9
- 八进制
  - 0On n:0-7
- 十六进制
  - 0Xn n:0-9,A-F
实数
- 带小数点或指数符号”E”的数。
复数
- 实部 real
- 虚部 imag

运算符

算术运算符
赋值运算符
- 左边只能是变量
- 简单赋值
- 复合赋值
- 链式赋值
- 序列解包赋值

数据类型转化

隐式转换
- 运算结果的数据类型向精度高的数据类型靠拢
- 整型<浮点<复数
显式转换
- 常用的是int()、float()和complex()

下面为需要掌握的相关函数：

(1) 内置模块(__builtin__)

divmod()
- 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
abs()
- 函数返回数字的绝对值。
pow()
- 方法返回 x^y（x的y次方）的值。
round(x,n)
- 返回浮点数x四舍五入后保留n位小数的值
min(),max()
- 会返回给定序列的最小/最大值
eval()
- 去掉参数最外侧引号并执行余下语句的函数

(2) 数学库模块math

math.pi
math.e
math.cos(x)--------输入弧度
math.sin(x)--------输入弧度
- (x*math.pi/180)
math.exp(x)
math.gcd(m,n)
math.log(x)
math.log10(x)
math.sqrt(x)
math.tan(x)

3 字符串类型

需要掌握引索、切片以及基本的format()格式化的方法。

转义字符

转义字符	描述
\\	反斜杠符号
\r	回车
\b	退格
\t	横向制表符
\n	换行

字符串基本操作符

+
- 拼接两个字符串
s*n
- 对字符串s复制n次
S1 in S2
- 子串测试。s1若是s2的子串返回True,否则 False
s[i]
- 索引操作,取某字符
s[n:m]
- 切片操作,返回索引号n到m但不包括m的子串；省略n表示从头，省略m表示取到结束
- 索引方式：正向递增和反向递减

字符串也内置了很多对字符串进行操作的函数：

string.upper()转换string 中的小写字母为大写
string.lower()转换string 中的小写字母为小写
string.capitalize()把字符串的第一个字符大写
string.find(str,beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和end 指定范围，则检查是否包含在指定范围内，如果是返回str开始的索引值，否则返回-1
string.join(seq)以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.rfind(str,beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找.
string.isnumeric() 全是数字返回TRUE
string.isalpha() 全是字母返回TRUE
string.replace(old,new) 替换
- 不改变引用对象
string.split('a') 按照'a'进行分离
string.strip(s) 去掉字符串s两边的空格

格式化输出

①%方法:

符号	描述
%c	单个字符
%s	字符串
%d	整数
%f	浮点数
%e	指数

x=1234.567，n=1234567，a="pythonOk"
print("x=%6.2fa=%sn=%d"%(x,a,n))

②format方法:

    "{0:*^12.5f}".format(45.45612346786)//0是序号  //其中*是填充字符//^是位置,<表示向左对齐,>表示向右对齐

③print方法

print([输出项, ...][, sep=分隔符][, end=结束符])

以下为需掌握的函数

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
ord() 函数是 chr() 函数（对于8位的ASCII字符串）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值。
oct() 函数将一个整数转换成8进制字符串。
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
len() 方法返回对象（字符、列表、元组等）长度或项目个数。
str()返回一个对象的string格式。

4 布尔类型

关系运算符
- 字符串比较规则：将两字符串从左到右一对一对按字符编码值比较，
  
  只要有一对不同比较结束。
逻辑运算符
- not
- and
- or

5 列表

列表生成

//直接使用[ ]生成列表Li=[ 1，20.9，-1]
//使用list函数//list 配合range产生列表a=list(range(1,10,3) )[1,4,7]University="Tongji"      ['T', 'o', 'n', 'g', 'j', 'i']Li=list(University)
//其他 ： 切片，列表方法append，列表推导式

列表删除

  Li=[ 1，20.9，-1] del Li  # 删除列表

列表遍历

枚举方式

R=list(range(100,1000))
for item in R:x=item % 10y=item // 10 % 10z=item//100if (x**3+y**3+z**3)==item:print(item)

下标索引

R=list(range(100,1000))
for i in range(len(R)):x=R[i] % 10y=R[i] // 10 % 10z=R[i]//100if (x**3+y**3+z**3)==R[i]:print(R[i])

enumerate函数

R=list(range(100,1000))
for i, item in enumerate(R):x=item % 10y=item // 10 % 10z=item//100if (x**3+y**3+z**3)==item:print('第'+str(i)+'项是水仙花',item)

注意

如果遍历的同时，需要对表项值修改，则必须用下标方式

列表分片

分片赋值

L=[1,2,3,4,5]
L[1:1]=[-9,-8,-7]
print(L)
结果为：[1, -9, -8, -7, 2, 3, 4, 5]

列表运算
- 加法
- 乘法
列表方法
- append()
  - append不换内存地址
  - +换内存地址
- count()
  - 对指定的元素计数，既元组在表中出现几次
- sort()
  - 列表是同一类型才可比较
- copy()
- clear()
- insert(i,x)
- pop(i)删除
- reverse()反转
map(函数名,列表)
- map函数将指定函数作用于列表的每个元素
zip函数
- zip函数将多个列表的对应元素整合为元组
- zip对象不能直接显示其包含的值，需要用list函数将zip对象转换为列表再显示

names=['张仟', '石戎',  '万行']
ages=[23, 21, 22]
for name,age in zip(names,ages):print(name,age)

enumerate

enumerate函数将一个列表的元素与其下标索引号组成元组

names=['张仟', '石戎',  '万行']
enu=enumerate(names)
print(enu)
print(list(enu))

列表推导式

li= [x*x for x in range(10)]

li= [x*x for x in range(10) if x%3==0]

6 元组

Python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号，列表使用方括号，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。此外，元组中只包含一个元素时，需要在元素后面添加逗号。

a=(1) 类型是int

a=(1,) 类型是tuple

7 字典

字典是另一种可变容器模型，且可存储任意类型对象，字典的每个键值key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号{}中。键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一；值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

字典方法
- dict.clear()删除字典内所有元素
- dict.copy()返回一个字典的浅复制
- dict.fromkeys(seq[, val])创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
- dict.get(key,default=None)返回指定键的值，如果值不在字典中返回default值
- dict.has_key(key)如果键在字典dict里返回true，否则返回false
- dict.items()以列表返回可遍历的(键, 值) 元组数组
- dict.keys()以列表返回一个字典所有的键
- dict.update(dict2)把字典dict2的键/值对更新到dict里
- dict.values()以列表返回字典中的所有值
- pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
- popitem()返回并删除字典中的最后一对键和值

8 集合

集合（set）是一个无序的不重复元素序列，可以使用大括号{}或者set()函数创建集合，注意：创建一个空集合必须用 set() 而不是{}，因为{}是用来创建一个空字典。下面是集合的一些操作：

add(x)元素x添加到集合s中，如果元素已存在，则不进行任何操作。
remove(x)将元素x从集合s中移除，如果元素不存在，则会发生错误。
len() 计算集合s元素个数。
clear() 清空集合s。
pop()随机移除元素
symmetric_difference()返回两个集合中不重复的元素集合
union()返回两个集合的并集
symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
difference()返回多个集合的差集

9 random库

random.seed(n) 创建n个随机数种子,之后的随机数不会改变
random.random() 随机产生0到1的一个浮点数
random.randint(a,b) 随机产生一个[m,n]之间的随机数
random.randrange(m,n,k) 随机产生一个[m,n)之间的随机数,可设置步长k
random.sample(seq,k) 从序列seq中随机抽取k个元素组成列表

三、结构化程序设计

(1) 顺序结构

输入数据
计算等处理
输出结果

(2) 选择结构

if 语句

if condition_1:statement_block_1
elif condition_2:statement_block_2
else:statement_block_3注意：
（1）在Python中语句块是使用冒号（：）开头，之后统一语句块内有相同的缩排，
不可混用不同空格数量（默认为4个），也不能混用空格、Tab键。
（2）语句块的使用和书写规则在下面选择结构的else、elif子句、循环结构的循环体、
函数定义中的过程体等都相同，不再重复说明。

(3) 循环结构

while 引导的无限循环 for 引导的遍历循环 continue 跳过本轮循环 break 跳出循环 pass 占据位置

（4）异常处理：掌握try-except的用法（难度：⭐⭐）

（5）else子语句

for  循环变量  in  序列： 循环体
else：语句块 while  表达式 ：循环体
else：语句块

注意： （1）序列可以是字符串、列表、元组、集合等，还可以是常用的range()函数。（2）循环的次数由序列中的成员个数决定。（3）书写规则序列后要有冒号、循环体要右缩排。

(4) 算法习题

辗转相除法

m,n=eval(input("请输入m,n"))
if m<n:   # 若m<n，则交换m,n=n,m
r=m%n
while(r!=0):m=nn=rr=m%n
print(n)

def gcd(m,n):if n==0:return melss:return gcd(n,m%n)

九九乘法表

下三角
for i in range(1,10):for j in range(i,10):print("{}*{}={:2d}".format(i,j,i*j),end=' ')print()print(" "*7*(i),end="")
上三角
for i in range(1,10):for j in range(1,i+1):print("{}*{}={:2d}".format(i,j,i*j),end=' ')print()

判断素数

def isprime(m):for i in range(2,m):if m%j==0:return Falsebreakreturn True

数字之美

for i in range(1,10):s="1"*iprint("{}{}*{}={}".format(" "*(20-2*i),s,s,int(s)**2))

级数和

//e
i=s=t=1
while (1/t>=0.0000001):t=t*is+=1/ti+=1
// π/4
i=t=1
s=0
while (abs(t)>=0.0000001):t=(-1)**(i-1)*(1/(2*i-1))s+=ti+=1

字符串加密

s="adsasdasdadaslsjfksdglsdfjlsdf"
code=""
for c in s:if "a"<c<"z":iasc=ord(c)+5if iasc>ord("z"):iasc-=26code+=chr(iasc)elif "A"<=c<="Z":iasc=ord(c)+5if iasc>ord("Z"):iasc-=26code+=chr(iasc)else:code+=c
print("加密后的字符串为：",code)

谁是凶手

for a in range(0,2):for b in range(0,2):for c in range(0,2):for d in range(0,2):if (a==0)+(c==1)+(d==1)+(d==0)==3 and a+b+c+d==1:print(a,b,c,d)
a,b,c,d是否等于1,代表他是否是凶手

分解因子

n=1325
print(n, '=', end = ' ')
i =2
while i<=n:while n % i == 0:      # 把n的所有因子i全部处理完     n=n//iif n == 1:print('{:d}'.format(i))else:print('{:d} *'.format(i), end = ' ')i+=1

矩阵相乘

A=[[1,3,4],[5,1,0]]
B=[[3,1,5],[7,0,2],[2,-1,3]]
C=[]
row=len(A)
col=len(B[0])
for i in range(row):oneRow=col*[0]for j in range(col):s=0.0for k in range(len(B)):s+=A[i][k]*B[k][j]oneRow[j]=sC.append(oneRow)
print(C)

四、函数

函数定义

def定义函数：函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()，任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数，return[表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def  函数名([参数表]) :函数体[return  语句]

def
- 关键字
函数名
- 用户自定义标识符
参数表
- 形式参数
冒号
- 必须写
形参
- 函数定义时
实参
- 函数使用时

函数的参数

默认参数：使用默认参数的时候，如果给形参传递了实参，则形参会接收实参的值。如果没有给这个形参传递实参，则形参会采用默认值。

def Point(n,value=1):p=[value]*nreturn p
//省略默认值参数调用：
p2=Point(3)
//指定默认参数值调用：
p1=Point(5,2)

一旦一个实参数开始指定了形参，后续的所有参数都必须指定形参关键字

位置参数：实参和形参的数量上必须要保持一致。

def quadricEquation(a,b,c):
x,y,z=1,8,3
roots=quadricEquation(x,y,z,10)

关键字参数：通过定义关键字获取实参的值，与形参的顺序无关。

可变参数：形参的数据会根据实参的数量的变化而变化。

元组型可变参数

参数的前面加*，可变长度参数将对应于它的实参转化为一个元组。
def calculate(cmd,*data):if cmd=="ave":return sum(data)/len(data)elif cmd=="sum":return sum(data)else:return data
a=calculate("av",123,34,5,6,6,7)

词典可变参数

参数的前面加**，对应的实在参数以“标识符=值”的方式传递，可变参数将对应的实参，转化为字典，以“标识符”为键，以“值”为值
def keyArgFunc(cmd,*data,**keyarg):   # keyarg 是一个字典print(cmd)for x in keyarg:print( x + ": " + str(keyarg[x]))
keyArgFunc('求和',no=10,name='李彤')

注意事项

根据定义规则，可变长参数必须放在函数形参表的最后，
在位置形参、默认值形参与可变长关键字都存在的函数中，其调用不符合形参名字方式。
因为一旦指定形参名字字调用，后续则必须也采用这种模式，但可变长度形参，其对应实参存在多个参数，所以无法为其实现形参关键字命名
一旦一个实参数开始指定了形参，后续的所有参数都必须指定形参关键字
函数中对形参直接赋值，不影响实参的值
通过形参对列表元素或对象属性值的变更，会导致对应实参值的变更
在传递参数前将序列解包，其格式为实参前面加*

def mul(*data):   # data是可变长参数s=1for item in data:s *=itemreturn s
L=(1,2,3,4,5)     # L是元组
print(mul(*L))

变量作用域

//显式使用全局变量，global
x=1
def fx():global xx=1000print("局部的x=",x)

fx()
print (“全局的x=", x)
//隐式使用全局变量def fx(n):z=100*x   //------->  x出现在=右侧，全局的       print("z=",z,'x=',x)
x=1     #全局变量xfx(3)print ("全局的x=", x)

lambda函数

函数名=lambda 形参表:表达式
s=lambda L: sum(L)/len(L)

高阶函数

//形式参数是一个函数
def add(x,y):return x+y
def subtract(x,y):return x-y
def myfun(x,y,f):return f(x,y)

s=myfun(2,4,add)
print(s)
s=myfun(2,4,subtract)
print(s)

递归函数

def  f(参数列表):If  递归结束条件:return 结束时的值else: f = 递归表达式End If
End Function

阶乘

def f(n):if n==1:return 1else:return f(n-1)*n

前n项和

def f(n):if n==1:return 1else:return f(n-1)+n

斐波那契

def fibo(n):if n==1 or n==2:return 1else:return fibo(n-1)+fibo(n-2)

字符串逆转

//把最后一个字符放前面
def rev(s):if len(s)==1:return selse:return s[-1]+rev(s[:-1])
//把最前面一个字符放在最后面
def rev(s):if len(s)==1:return selse:return rev(s[1:])+s[0]

汉诺塔问题

//n-1个盘从A借助C移动B
//从A移动一个到C
//n-1个盘从B借助A移动C
def Hanoi(n,A,B,C):if n==1:print(A+"→"+C)else:Hanoi(n-1,A,C,B)print(A + "→" + C)Hanoi(n - 1, B, A ,C)
Hanoi(3,"A","B","C")

最大公约数

//辗转相除法
def gcd(m,n):if m%n==0:return nelse:return gcd(n,m%n)
//辗转相减法
def gcd(m,n):if m<n:m,n=n,mif m-n==0:return nelse:return gcd(n,m-n)

数制转化

//2~8
def Tran(d,r):if d==0:return ""else:return Tran(d // r,r) + str(d % r)
//2~16
def Tran(d,r):if d==0:return ""if r<10:return Tran(d//r,r)+str(d%r)else:if d%r<10:    return Tran(d//r,r)+str(d%r)else:return Tran(d//r,r)+chr(d%r-11+ord('A'))

五、文件和数据格式化

1 打开、关闭

//打开文件
fp = open(filename)
fp = open(filename , "rt",encoding='utf-8')
//注：用\\转义表示\
"D:\\Test\\Scores.txt "
//r取消转义
r"D:\Test\Scores.txt“

//open函数的返回值是文件对象
//文件对象内置了一个迭代器


//关闭文件
fp.close()

open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出OSError。完整的语法格式为： open(file,mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None）

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

2 文件访问

读文件

//read方法
返回值是字符串（整个文件内容）,一次性读文件所有内容。
fp=open("D:\Test\Scores.txt","r")
all=fp.read()

//readline方法
fp=open(r"D:\Test\Scores.txt","r")
while True:str=fp.readline()if not str:breakprint(str, end="")
fp.close()

//readlines方法
返回值是列表,整个文件内容当成一个列表，一行一个列表元素

fp=open(r"D:\Test\Scores.txt","r")
lines=fp.readlines()
print(lines)
fp.close()

写文件

//write方法
参数只能是字符串： fp.write(88)报错
写数据时不会自动换行*****

fp.write("185125")
fp.write("徐文静")
fp.write("88")

//writelines方法
lines是字符串列表
fp.writelines(lines)

3 文件编码

ANSi
- 西文字符
  - ASCII码一个字节
- 汉字
  - GBK码二个字节
UNICODE
- 西文字符
  - 加两个十六进制0，41H 00 41H
- 汉字
  - 编码与GBK不同
UTF-8
- UNICODE的变种所有字符:1~6字节

4 文件路径

绝对路径
相对路径

5 异常处理

try:pass
except:pass
finally:pass

6 中文分词

//精准模式
import jieba
lst=jieba.lcut("小米爱神的箭阿萨德大声道")

7 图像处理

PIL

from PIL import Image
//打开图像
im=Image.open(r"../Datas/1.jpeg")
//转化图像
im=im.convert("L")
//显示图像
im.show()
//保存图像
im.save(r"../Datas/1-test.jpeg")
//获取图像位置(10,10)像素值
im.getpixel((10,10))
//缩略图
im_thumbnail=im.thumbnail((128,128))
//缩放
im_resize=im.resize((200,200))
//旋转
im_rotate=im.rotate(-45)#顺时针45度

8 习题

统计人物出现次数

import jieba
file=open(r"../Datas/红楼梦.txt","r",encoding="utf-8")
txt=file.read()
wordlist=jieba.lcut(txt)
actors=[('贾宝玉','宝玉'),('林黛玉','黛玉'),('王熙凤','凤姐')]
dicActors={}
for actor in actors:count1=wordlist.count(actor[0])count2=wordlist.count(actor[1])dicActors[actor[0]]=count1+count2
items=list(dicActors.items())
items.sort(key=lambda x:x[1],reverse=True)
print(items)
for i in range(len(items)):word,count=items[i]print(items[i][0],items[i][1])

六面向对象

类的成员
- 私有成员 __x两个下划线开头
- 保护成员 _x一个下划线开头
- 公有成员无下划线
判断是否实例
- isinstance
构造函数
- __init__
派生类
- class 派生类名(父类名):
- 派生类的构造函数
  - 父类ming.__init__(鸡肋构造函数参数表)

迭代器

可迭代对象

for i in list:

迭代器

class Fibo():def __init__(self,max)://类构造函数self.max=maxself.n,self.a,self.b=0,0,1def __iter__(self)://返回迭代器对象并初始化return selfdef __next__(self)://从当前迭代器返回当前值,并改变下一次调用的状态if self.n<self.max:temp=self.bself.a,self.b=self.b,self.a+self.bself.n+=1return tempreturn StopIteration

生成器

def Fibo(n):a,b=0,1while a<n:value=aa,b=b,a+byield value

七数据可视化

1 图标的组成

容器层
- Canvas画布
- Figure 绘图区
- Axes 坐标系
辅助显示层
- 标题
- 坐标轴
- 坐标轴名称
- 坐标轴刻度
- 坐标轴刻度标签
- 图标边框线
- 网格线
- 图例
图像层
- 折线图
- 散点图
- 柱状图
- 饼图

2 图像绘制函数

plt.axis()
- 显示当前坐标轴的范围
plt.axes()
- 显示坐标系风格的绘图区
plt.xlim(left,right)
- 设置坐标轴的取值范围
plt.text(x,y,s)
- 在指定位置添加注释文本
plt.grid()
- 设置绘图区的网格显示
plt.title(label,loc='center')
- 在指定位置显示标题
plt.xlabel(xlabel)
- 设置X轴的标题
plt.xticks(ticks,labels)
- 设置分类轴和数值
plt.legend()
- 设置图例显示
plt.fill(x,y,color)
plt.rcParams['font.sans-serif']=['SimHei']
- 设置中文字体,正常显示汉字
- 苹果电脑设置为plt.rcParams['font.sans-serif']=['Arial Unicode MS']
Linestyle
- '-'画实线
- '--'画长虚线
- ':'画短虚线
- 'None' 不画线
marker
- 'o'圆圈
- '.'点
- '*'星号

函数种类

线条

  import matplotlib.pyplot as pltplt.plot([5,2,1], [3,1,3], 'yD-', label='line 1', linewidth=4)plt.legend(loc="center right")

饼图

import matplotlib.pyplot as plt
score = [0.16,0.28,0.32,0.14,0.1]       #各等级的成绩数据
plt.rcParams['font.sans-serif']=['SimHei']
plt.title("成绩分布图")                     #图表标题
labels = ['优秀', '良好', '中', '及格','不及格']   #数据标记
explode = (0.2, 0, 0, 0,0)                   #裂开第1块
plt.axis("equal")
plt.pie(score, explode=explode, labels=labels, autopct='%4.1f%%')
# autopct=‘%4.1f%%’控制数据标记的格式化显示,显示1位小数
plt.legend(bbox_to_anchor=(1, 0.6))       #设置图例显示位置

散点图

from math  import  *
import matplotlib.pyplot as plt
plt.rcParams['axes.unicode_minus']=False
plt.rcParams['font.sans-serif']=['SimHei']
fig1=plt.figure(figsize=(8,4),facecolor='w')
fig1.add_subplot(121)                     #添加第1个子绘图区
plt.title('标记绘制的图案')
a=0
while a<=2 * pi:         #每次产生一个坐标点r=sin(4*a)               #花瓣数为8x,y=r*cos(a),r*sin(a) plt.plot(x,y,'b*',linewidth=4)     #绘制星号a+=0.02
fig1.add_subplot(122)          #添加第2个子绘图区
plt.title('散点绘制的图案')
a=0
while a<=2* pi:       r=sin(5*a)                        #花瓣数为5x,y=r*cos(a),r*sin(a)plt.scatter(x,y,c="g",marker="o")  #绘制绿色圆圈a+=0.02

3 习题

平方曲线和倒数曲线

import matplotlib.pyplot as plt
import numpy as np
# plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
fig,axes=plt.subplots(2,1,figsize=(6,6))

x1=np.linspace(-1,1,30)
y1=x1*x1
x2=np.linspace(0,1,30)
y2=1/x2

plt.subplot(211)
plt.title("平方曲线")
plt.plot(x1,y1)

plt.subplot(212)
plt.title("倒数曲线")
plt.plot(x2,y2)
plt.show()

正弦函数

import matplotlib.pyplot as plt
import math
import numpy as np
x=np.linspace(-math.pi,math.pi,100)
y=list(map(math.sin,x))
plt.scatter(x,y,marker='*')
# plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
plt.title("Sin函数曲线")
plt.xlim(-4,4)
plt.ylim(-1.2,1.2)
plt.plot(range(-4,5),len(range(-4,5))*[0])
plt.plot(len(range(-2,3))*[0],range(-2,3))
plt.text(0.12,1,"Y")
plt.text(-math.pi-0.1,0-0.1,"-pi")
plt.text(0,0,"0")
plt.text(4-0.1,0-0.1,"X")
plt.text(math.pi,0,"pi")
plt.show()

心形线

import matplotlib.pyplot as plt
import math
import numpy as np
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
theta = np.linspace(0.0, 2 * np.pi, 1000)
a = 5
rho = a * (1 - np.sin(theta))
# plt.subplot(polar=True)
plt.polar(theta, rho, c = 'r')
plt.show()
theta = np.linspace(0.5*np.pi, 1.5*np.pi, 1000)
sintheta = np.sin(theta)
a = 1
y = a * sintheta * (1 - sintheta)
x = np.sqrt((1 - sintheta) ** 2 - y ** 2)
x1 = np.hstack((x,-x[::-1]))  #x[::-1]意思是反转x
y1 = np.hstack((y,y[::-1]))
plt.plot(x1, y1, c = 'r')
plt.title("心形曲线-直角坐标系")
plt.show()

饼图

import matplotlib.pyplot as plt
partial=[0.2,0.1,0.3,0.13,0.27]      #各等级的成绩数据
plt.rcParams['font.sans-serif']=['SimHei']
plt.title("成绩分布图")                     #图表标题
consumes=['学习用品','日常用品','伙食费','通讯费','其他开支']   #数据标记
explode = (0.2, 0, 0, 0,0)                   #裂开第1块
plt.axis("equal")
plt.pie(partial, explode=explode, labels=consumes, autopct='%4.1f%%')
plt.legend(bbox_to_anchor=(1, 0.6))
plt.show()

词云

from PIL.Image import Image
import jieba
import matplotlib.pyplot as plt
import numpy as np
from wordcloud import WordCloud
fp=open(r"../Datas/三国演义.txt",'r',encoding='utf-8')
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
characters=[("曹操"),("董卓"),("黄忠"),("刘备"),("刘表"),("鲁肃"),("吕布"),("马超"),("马岱"),("孟获"),("庞德"),("孙权"),("孙策"),("魏延"),("袁绍"),("赵云"),("周瑜")]
words=fp.read()
wordlist=jieba.lcut(words)
dictcharacters={}
for character in characters:dictcharacters[character]=wordlist.count(character)
items=list(dictcharacters.items())
# items.sort(key=lambda x:x[1],reverse=True)
characterlist=[]
countslist=[]
for i in items:characterlist.append(i[0])countslist.append(i[1])
plt.subplot(211)
plt.bar(characterlist,countslist,width=0.8)
mask=np.array(Image.open(r"../Datas/1.jpeg"))
wcd=WordCloud(background_color="white",
font_path="/Users/tangyufeng/Downloads/SimHei.ttf", max_words=1000,mask=mask ,max_font_size=100)
characterSS=''.join(characterlist)
print(characterSS)
mywd=wcd.generate(characterSS)
plt.subplot(212)
plt.axis('off')
plt.imshow(mywd)
plt.show()

散点图

import matplotlib.pyplot as plt
import numpy as np

fp=open(r"../Datas/epoch.txt",'r',encoding='utf-8')
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
trainlosses=[]
trainaccuracy=[]
testlosses=[]
testaccuracy=[]
datas=fp.readlines()

for unit in datas:trainlosses.append(float(unit.split('\t')[0]))trainaccuracy.append(float(unit.split('\t')[1]))testlosses.append(float(unit.split('\t')[2]))testaccuracy.append(float(unit.split('\t')[3]))
x=range(0,len(trainaccuracy))
plt.subplot(211)
plt.xlabel("训练轮数")
plt.ylabel("准确率")
# plt.legend('lowwer right')
plt.scatter(x,trainaccuracy,label='训练集的准确率')
plt.plot(x,testaccuracy,label='验证集的准确率')
plt.title("训练集和验证集的准确率")
plt.legend()
plt.subplot(212)
plt.xlabel("训练轮数")
plt.ylabel("损失值")
plt.scatter(x,trainlosses,label='训练集的损失值')
plt.plot(x,testlosses,label='验证集的损失值')
plt.title("训练集和验证集的损失值")
plt.legend()
plt.show()

八、第三方库

1 turtle库

绘制状态函数：pendown()、penup()、pensize()以及对应别名为pd()、pu()、width()；
颜色控制函数：color()、pencolor()、begin_fill()、end_fill()；
运动控制函数：forward()、backward()、right()、left()、setheading()、goto()、circle()以及对应别名fd、bk()、rt()、lt()、seth()

2 random库

考查seed()、random()、randint()、getrandbits()、randrange()、uniform()、choice()、shuffle()、sample()

3 time库

时间处理函数：time()、gmtime()、localtime()、ctime()
时间格式化函数：mktime()、strftime()、strptime()
计时函数：sleep()、perf_counter()

4 pyinstaller库和jieba库

记住pyinstaller打包文件的命令pyinstaller-Fc:...\your_python_file.py以及jieba中的jieba.lcut()方法即可

5 常见的第三方库

网络爬虫：requests、scrapy、pyspider

数据分析：numpy、pandas、scipy

文本处理：pdfminer、python-docx、beautifulsoup4

数据可视化：matplotlib、seaborn、mayavi

用户图形界面：PyQt5、wxPython、PyGObject

机器学习：scikit-learn、TensorFlow、mxnet

Web开发：Django、pyramid、flask

游戏开发：pygame、Panda3D、cocos2d