[同济大学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 % 10
    y=item // 10 % 10
    z=item//100
    if (x**3+y**3+z**3)==item:
        print(item)

下标索引

R=list(range(100,1000))
for i in range(len(R)):
    x=R[i] % 10
    y=R[i] // 10 % 10
    z=R[i]//100
    if (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 % 10
    y=item // 10 % 10
    z=item//100
    if (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 
 
九九乘法表
 
下三角
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 False
                break
            
    return True      
 
 
数字之美
 
for i in range(1,10):
    s="1"*i
    print("{}{}*{}={}".format(" "*(20-2*i),s,s,int(s)**2))
​
 
 
级数和
 
//e
i=s=t=1
while (1/t>=0.0000001):
  t=t*i
  s+=1/t
  i+=1
// π/4
i=t=1
s=0
while (abs(t)>=0.0000001):
  t=(-1)**(i-1)*(1/(2*i-1))
  s+=t
  i+=1
 
 
字符串加密
 
s="adsasdasdadaslsjfksdglsdfjlsdf"
code=""
for c in s:
    if "a"ord("z"):
            iasc-=26
        code+=chr(iasc)
    elif "A"<=c<="Z":
        iasc=ord(c)+5
        if iasc>ord("Z"):
            iasc-=26
        code+=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//i
        if 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.0
        for k in range(len(B)):
          s+=A[i][k]*B[k][j]
        oneRow[j]=s
   C.append(oneRow)
print(C)
 
 
四、函数 
函数定义
 
def定义函数：函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()，任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数，return[表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
 
def  函数名([参数表]) :
    函数体
    [return  语句]
 
 
def
 
  
 
关键字
  
函数名
 
  
 
用户自定义标识符
  
参数表
 
  
 
形式参数
  
冒号
 
  
 
必须写
  
形参
 
  
 
函数定义时
  
实参
 
  
 
函数使用时
 
函数的参数
 
 
默认参数：使用默认参数的时候，如果给形参传递了实参，则形参会接收实参的值。如果没有给这个形参传递实参，则形参会采用默认值。
 
def Point(n,value=1):
    p=[value]*n
    return 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=1
    for item in data:
        s *=item
    return s
L=(1,2,3,4,5)     # L是元组
print(mul(*L))   
 
变量作用域
 
//显式使用全局变量，global
x=1
def fx():
    global x
    x=1000
    print("局部的x=",x)
​
fx()
print (“全局的x=", x)
//隐式使用全局变量
  def fx(n):
      z=100*x   //------->  x出现在=右侧，全局的       
      print("z=",z,'x=',x)
​
  x=1     #全局变量x
  fx(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 1
   else:
     return f(n-1)*n
 
 
前n项和
 
def f(n):
    if n==1:
        return 1
    else:
        return f(n-1)+n
 
 
斐波那契
 
def fibo(n):
  if n==1 or n==2:
    return 1
  else:
    return fibo(n-1)+fibo(n-2)
 
 
字符串逆转
 
//把最后一个字符放前面
def rev(s):
    if len(s)==1:
        return s
    else:
        return s[-1]+rev(s[:-1])
//把最前面一个字符放在最后面
def rev(s):
    if len(s)==1:
        return s
    else:
        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 n
  else:
    return gcd(n,m%n)
//辗转相减法
def gcd(m,n):
    if m 
 
数制转化
 
//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:TestScores.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:TestScores.txt","r")
all=fp.read()
​
//readline方法
fp=open(r"D:TestScores.txt","r")
while True:
    str=fp.readline()
    if not str:
        break
    print(str, end="")
fp.close()
​
//readlines方法
返回值是列表,整个文件内容当成一个列表，一行一个列表元素
​
fp=open(r"D:TestScores.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=max
        self.n,self.a,self.b=0,0,1
    def __iter__(self)://返回迭代器对象并初始化
        return self
    def __next__(self)://从当前迭代器返回当前值,并改变下一次调用的状态
        if self.n  
生成器
 
def Fibo(n):
  a,b=0,1
  while a 
七 数据可视化 
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 plt
  plt.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)               #花瓣数为8
    x,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)                        #花瓣数为5
    x,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