python学习笔记

基本语法元素

---

• 程序的格式框架，叫段落格式，是python语法的一部分，可以提高代码的可读性和可维护性

python从语言采用严格的缩进来表示程序逻辑。也就是我们所说的python程序间的包含与层次关系。一般代码不要求缩进。顶行编写布鲁空白。在if，while，for，def，class等保留字所在完整语句后通过英文的“：”结尾并在之后行进行缩进，表明后续代码与紧邻无缩进语句的所属关系。

• 缩进

缩进可以用Tab键表示，也可以用多个空格实现（一般四个空格），但两者不能混用，建议采用4个空格方式书写代码。

for i in range(1,10):
    for j in range (1,1+i):
        print('{}*{}={:2}'.format(j,i,i*j),end='   ')
    print()

• 注释

注释是代码中的辅助性文字，会被编译器或解释器略去，不被计算机执行，一般用于程序员对代码的说明。python语言中使用“#”表示一行注释的开始。注释可以在一行中任意位置通过“#”开始，其后面的本行内容被当作注释，而之前的内容依然是python执行程序的一部分

注释的作用

1. 注释一般用于在代码中标明作者和版权信息
2. 解释代码原理和用途
3. 通过注释单行代码辅助程序调试

#作者名称:wdnmd
#编写时间:2020-11-20
print("hello world")#print()函数用于打印输出
#print("hello Python")
print("hello Java")

• 续行符

python程序是逐行编写的，每行代码长度并无限制，但从程序员角度，单行代码太长并不利于阅读。这个时候就可以使用续行符将单行代码分割为多行表达

python中的续行符为" \ "。续行符之后不润许在存在空格，即续行符后直接换行。

print('{}是{}的首都'.format(\
    '北京',\
    '中国'\
    ))

---

• 语法元素的名称

python语言的基本单位是"单词"，少部分单词是python语言规定的，被称为保留字。大部分单词是用户自己定义的，通过命名过程形成了变量或函数，用来代表数据或代码，称为标识符。

• 变量

变量是保存和表示数据值的一种语法元素，变量的值是可以改变的，通过赋值运算符“ = ”方式被修改，变量可以随时命名，随时赋值，随时使用。

• 保留字

保留字也称keyword关键字，被编程语言内部定义并保留使用的，每种程序设计语言都有一套保留字，保留字一般用来构成程序的整体框架，python3.x中一共有35个保留字

False await else import pass

None break except in raise

True class finally is return

and continue for lambda try

as def from nonlocal while

assert del global not with

async elif if or yield

python中的保留字也是大小写敏感的。举例：True为保留字，true不是保留字

---

• 标识符

标识符可以简单的理解为一个名字，主要用来标识变量，函数，类，模块和其他对象的名称

• 命名规则

1. 字母，数字，下划线
2. 第一个字符不能是数字
3. 不能是python中的保留字
4. 之允许使用ISO-Latin（ISO-8859-1）字符集中的A-Z和a-z
5. 允许使用中文，但不建议

标识符对大小写敏感，name和Name是两个不同的名字

---

• 数据类型

计算机对数据进行运算时需要明确数据的类型和含义。例如1001001到底表示的是十进制的数字，还是二进制的数字，还是表示一个字符串？数据类型就是用来表达数据的含义 ，消除计算机对数据理解的二义性

• 数值类型

表示数字或熟知的数据类型成为数值类型。

python提供的3种数值类型：

1. 整数类型：与数学中的整数一致包含正，负，0，一个整数有二进制，八进制，十进制，十六进制4种表示方式。
2. 浮点数类型：与数学中的小数一致，没有取值范围限制，可正，可负。有两种表示形式，一种是小数点的形式，另外一种是科学计数法，浮点数只有十进制形式

a=123.456
print(a)
#123.456
b=1.23456e2
print(b)
#123.456

3.复数：与数学中的复数一致，采用a+b j 的形式表示，存在实部和虚部

---

• 字符串类型

计算机经常处理文本信息，文本信息在程序中使用字符串类型表示。在python中使用单引号或双引号括起来的一个或多个字符来表示，单引号和双引号的作用相同。

a='hello'
b="hello"
print(type(a))
#<class 'str'>
print(type(b))
#<class 'str'>

字符序列有两种序号体系：

1. 正向递增序号：有效范围为[0,N-1],其中N为字符串中字符的个数。最左侧的字符序号为0，依次向右递增，最右侧字符序号为N-1
2. 反向递增序号：有效范围为[-1,-N]，其中N为字符串中字符的个数。最右侧的字符序号为-1，依次向左递增，最左侧字符序号为-N

反向递减序号：<----------------

-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

h

e

l

l

o

，

w

o

r

l

d

0 1 2 3 4 5 6 7 8 9 10

正向递增序号---------------------------->

两种索引可以同时使用，以下代码为对单个字符进行的索引

s='hello,world'
print(s[1])
#e
print(s[-10])
#e

还可以[ N:M ] 格式获取字符串的子串，这种操作被称为切片操作，[ N：M ]获取字符串中从N到M （但不包含M）的连续的子字符串。N和M都表示的是索引序号，可能混合使用正向递增序号和反向递减序号

s='hello,world'
print(s[0:5])
#hello
print(s[0:-6])
#hello

通过python默认提供的len()函数获取字符串的长度，一个中文字符和一个英文字符的长度都记为1。

s='hello,world'
print(len(s))
#11

---

• 程序的语句元素
• 表达式：产生或计算新数据值的代码片段称为表达式。类似于数学中的公式，一般由数据和操作符构成。

10+30
#40

• 赋值语句

对变量进行赋值的一行代码被称为赋值语句。在python中使用一个‘’=“表示赋值。即将等号右侧表达式计算后的结果值赋给左侧的变量。

1. 基本赋值语句语法：变量等于表达式

   a=10+20
   print(a)
   #30

2. 同步赋值语句
   给多个变量进行赋值
   同步赋值语句语法：变量1，变量2，.......，变量N=表达式1，表达式2，........ ，表达式N

3. 应用最多的是互换变量的值，即交换两个变量的值。

---

• 引用

使用当前程序之外已有的功能代码，这个过程叫引用。python语言中使用import这个保留字引用当前程序以外的功能库

引用后使用功能库.函数名（）的方式调用基本功能,这种方式简称为”A.B（）“

import turtle
turtle.fd(-200)
turtle.right(90)
turtle.circle(200)
turtle.done()

---

• 其他语句

除了赋值语句之外，python还有分支语句和循环语句。

分支语句：根据判断条件选择程序执行路线。一般包含单分支结构，双分支结构和多分支结构。

• 单分支语法结构：
  if 条件：
  语块
  能够产生Ture或False的语句都可以作为条件，当条件为True时，则执行语句块中的内容。

  num = eval(input("输入一个整数"))
  if  0<=num<=100:
      print('输入整数在0到100之间（含）')
  #输入一个整数88
  #输入整数在0到100之间（含）

• 双分支语法结构：
  if 条件:
  语块1
  else：
  语块2
  当条件为True时，执行语句块1，当条件为False时，执行语句块2.其中if....else都是保留字

  num = eval(input("输入一个数字"))
  if  num>100:
   print('输入数字大于100')
  else:
   print('输入数字小于等于100')
  '''
  输入一个数字80
  输入数字小于等于100
  
  输入一个数字120
  输入数字大于100
  '''

• 条件循环的语法结构：
  while 条件：
  语句块1
  语句块2
  当条件为True时，执行语句块1，当条件为False时，执行语句块2.

  n=10
  while n<100:
      print(n,end=' ')
      n=n+3
  #10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79 82 85 88 91 94 97

  基本输入输出函数

input()函数从控制台获得用户的一行输入，无论用户输入什么内容，input（）函数都以字符串类型返回。input（）函数可以包含一些提示性文字，用来提示用户。

1. input（）语法格式：
   变量=input（提示性文字）
   无论用户输入的是数字还是字符，input（）函数统一按照字符串类型输出，为了后续能够操作用户输入的信息，需要将输入指定一个变量进行储存。

2. eval（）函数
   eval（s)函数将去掉字符串s最外侧的引号，并按照python语句方式执行去掉引号后的字符内容
   eval语法格式：
   变量=eval（字符串）
   变量用来保存对字符串内存进行python运算的结果

   a=eval('1.2')
   print(a,type(a))
   a=eval('1.2+3.4')
   print(a,type(a))
   #1.2 <class 'float'>
   #4.6 <class 'float'>

   当eval处理字符串时，字符串去掉了两边的引号，python将其解释为一个变量，由于这个变量在之前别有定义，因此解释器报错。如果定义变量python并赋值，在运行这个语句就没有问题
   eval（）函数经常与input（）函数一起使用，用来获取用户输入的数字

3. eval（）与input（）函数一起使用的语法：
   变量 =eval（input（提示性文字））
   用户输入的数字，包括小数和负数，input（）解析为字符串，再由eval（）去掉字符串引号，将被直接解析为数字保存到变量中

   value=eval(input('请输入:'))
   print(value,type(value))
   #请输入:123.98
   #123.98 <class 'float'>

---

• print()函数

print（）函数用于输出字符串或单个变量

python函数的三种用法：

1. 仅用于输出字符串或单个变量
   print（待输出字符串或变量）
   对于字符串print（）函数输出后将出掉两侧引号，对于其他类型，则会直接输出。

   print('中国加油')
   print(100)
   print([1,2,3,4,5])
   print(["python","java","html"])
   #中国加油
   #100
   #[1, 2, 3, 4, 5]
   #['python', 'java', 'html']

   当print（）输出字符串表示时，字符串统一使用单引号表示。在 [ ] 中的字符串都使用双引号，但是在被print（）函数打印输出时，输出结果都采用了单引号

2. 用于输出一个或多个变量，输出后的各变量之间用一个空格分隔。
   print（变量1，变量2，......，变量N）

   value=123.456
   print(value,value,value)
   print('wdnmd','wdnmd')
   #123.456 123.456 123.456
   #wdnmd wdnmd

3. 用于混合输出字符串与变量的值，其中输出字符串模板中使用 { } 表示一个槽位，每个槽位对应 .format（）中的i一个变量。
   print（输出字符串模板.format（变量1，变量2，......，变量N））

   a,b=10,20
   print('整数{}和整数{}的差是:{}'.format(a,b,a-b))
   #整数10和整数20的差是:-10

print（）函数输出文本时默认会在最后增加一个换行，如果不希望在最后增加这个换行，或者希望输出文本后增加其他内容，可以对print（）函数的end参数进行赋值。

• 语法为：print（待输出的内容，end=‘增加的输出结尾’）

a=10
print(a,end='.')
print(a,end='%')
#10.10%

整数类型

python中的整数没有取值范围的限制，理论上来讲只要能够储存，python可以使用任意大小的整数。

整数类型有4种进制表示方式。默认情况下，采用十进制，如果需要表示其他进制方方式则需要引导符号

进制种类	引号符号	描述
二进制	0b或0B	由0到1组成，例0b1001，0B10001
八进制	0o或0O	由0到7组成，例0o5762，0O5674
十六进制	0x或0X	由0到9，A到F或a到 f 组成，例0x455Fe，0X6598A
十进制	无	默认情况 123

不同进制的整数之间可以直接运算或比较，程序无论采用哪种进制表达数据，计算内部都以相同的格式储存数值，进制之间默认以十进制方式显示

---

浮点数类型

浮点数表示带有小数的数值，在python语言中的浮点数类型必须带有小数部分，小数部分可以是0.比如说98是整数，98.0就是浮点数

浮点数有两种表示方法：十进制表示形式和科学计数法表示形式。浮点数没有其他进制表示形式

科学计数法使用字母e或E作为幂的符号，以10为基数。举例<a>e<b>表示a*10^b。1.01e3表示1.01*10^3。-1.01e-3表示-1.01*10^-3就是-0.00101

浮点数的取值范围和小数精度受不同计算机系统的限制。浮点数的取值范围 [ -10^308,10^308 ] ，浮点数之间的区分精度约为2.22*10^-16。浮点数类型的数值范围和小数精度足够 “ 可靠 ” 。一般认为浮点数类型没有范围限制。

相同数值整数的运算精度更高

python语言的浮点数运算存在一个 “不确定尾数”问题，即两个浮点数运算时，有可能会增加一些 “不确定”的尾数。他会对浮点数运算结果的判断造成一定困扰。由于0.1+0.2的运算结果中存在不确定尾数，所以与0.3判断是否相等时结果为False

print(0.1+0.2==0.3)
#False

运用内置函数round(),用于进行四舍五入的运算，所以可以使用round()限制运算保留位数，去掉不确定尾数

print(round(0.1+0.2,3)==0.3)
#True

---

复数类型

复数类型表示数学中的复数。复数使用，a+bj的形式表示，称为实部和虚部。其中j称为“虚部单位”，它被定义为j=根号-1.

复数采用（a，b）表示a+bj，当 b等于1时，1不能省略，采用1j表示复数，而j则表示python中的一个变量。

复数类型中实部和虚部的变量都是浮点类型，对于复数z，可以用z.real和z.imag分别获取实数部分和虚数部分

(1.23e4+5.67e4j).real
#12300.0
(1.23e4+5.67e4j).imag
#56700.0
1.23e4+5.67e4j.imag
#69000.0

---

数值运算操作符

操作符及运算	描述
x+y	x与y之和
x-y	x与y之差
x*y	x与y之积
x/y	x与y之商，产生结果为浮点数
x//y	x与y之商，产生结果为整数
x%y	x与y之商的余数，也称为模运算
-x	x的负数
x	x本身
x**y	x的y次幂，即x^y

数值运算可能改变结果的数据类型，类型的改变与运算符有关。

规则如下

1. 整数和浮点数混合运算。输出结果是浮点数
2. 整数之间运算 ，产生结果类型 与操作符相关，除法运算的结果是浮点数
3. 整数和浮点数与复数运算，运算结果是复数

数值运算符与赋值运算符相连组成增强赋值操作符。如+= 、--=、*=、/=、//=、%=、**=，使用增强赋值操作符能够简化对同一变量赋值语句的表达式。

数值运算符与赋值运算符=之间不能有空格

---

数值运算函数

内置数学运算函数

序号	函数	描述
1	abs(x)	x的绝对值
2	divmod(x,y)	(x//y,x%y)输出元组形式的商与余数
3	pow(x,y)或pow(x,y,z)	x**y或（x**y)%z，幂运算
4	round(x)或round(x,d)	对x进行四舍五入保留d位小数，d省略则返回四舍五入的整数值
5	max(x1,x2,……,xn)	N个数的最大值
6	mir(x1,x2,……,xn)	N个数的最小值

---

字符串

字符串类型及格式化

字符串又称为字符序列，根据字符串的内容多少分为单行字符串和多行字符串。

单行字符串可以由一对单引号或一对双引号作为边界，单引号和双引号的作用相同。当使用单引号时双引号可以作为字符串的一部分。使用双引号时，单引号可以作为字符串的一部分。

多行字符串由一对三引号或三双引号作为边界表示，二者作用相同。

反斜杠字符 \ 是一个特殊的字符，在python字符串中表示”转义“，即该字符与后面相邻的一个字符共同组成了新的含义。

常见的转义字符：

1. \n 表示换行
2. \\ 表示反斜杠
3. \' 表示单引号
4. \" 表示双引号
5. \t 表示制表位

---

字符串索引

对字符串中某个字符的检索称为索引

语法如下：

字符串或字符串变量 [ 序号 ]

字符串的索包括：正向递增序号和反向递增序号。如果一个字符产的长度为N，正向递增需要以最左侧字符序号为0，向右依次递增，最后右侧泽夫序号为N-1。反向递减序列以最右侧字符序号为-1，向左依次递减，最左侧字符序号为-N，这两种索引字符的方法可以同时使用。

---

字符串的切片

对字符串中某个子串或区间的索引称为切片。

语法如下：

字符串或字符变量 [ N : M ]

切片获取字符串N:M (不包含M)的子字符串，其中，N和M为字符串的索引序号，可以混合使用正向递增序号和反向递减序号。切片要求N和M都在字符串的索引区间，如果N大于M，则返回空字符串。如果认将N设为0：如果M缺失，则默认表示到字符串结尾。

字符串类型的操作

字符串操作符

操作符	描述
x+y	连续两个字符串x与y
x*n或n*x	复制n次字符串x
x in s	如果x是s的字串,返回True，否则返回False

---

字符串处理函数

操作	描述
len(x)	返回字符串x的长度，也可以返回其他组和数据类型的元素个数
str(x)	返回任意类型x所对应的字符串形式
chr(x)	返回Unicode编码x对应的单字符
ord(x)	返回单字符x表示的Unicode编码
hex(x)	返回整数x对应十六进制数的小写形式字符串
oct(x)	返回整数x对应八进制的小写形式字符串

len（x）返回字符串x的长度，以Unicode字符为计数单位，中英文字符及标点符号等都是一个长度单位。

str（x）返回x的字符串形式，其中x是数字类型或其他类型

chr（x）和ord（x）函数用于在单个字符和Unicode编码值之间进行转换。chr（x）函数返回Unicode编码对应的字符，ord（x）函数返回单个字符x对应的Unicode编码。

hex（x）和oct（x）函数分别返回整数x对应十六进制和八进制的字符串形式，字符串以小写形式表示

>>> len('python')
6
>>> len('我爱你中国')
5
>>> str(10010)
'10010'
>>> str(0x3f)
'63'
>>> str(3.1415926)
'3.1415926'
>>> chr(1010)
'ϲ'
>>> chr(10000)
'✐'
>>> ord('杨')
26472
>>> hex(1010)
'0x3f2'
>>> oct(-255)
'-0o377'

---

字符串处理方法

方法	描述
str.lower()	返回值字符串str的副本，全部字符小写
str.upper()	返回值字符串str的副本，全部字符大写
str.split(sep=None)	返回一个列表，由str根据sep被分割的部分构成，省略sep默认以空格分隔
str.count(sub)	返回sub子串出现的次数
str.replace(old,new)	返回字符串str的副本，所有old字串被替换成new
str.center(width,fillchar)	字符串居中函数，fillchar参数可选
str.strip(chars)	从字符串str中去掉在其左侧和右侧chars中列出的字符
str.join(item)	将item变量的每一个元素后增加一个str字符串

字符串副本指返回一个新字符串，但不改变原来的str

str.lower()和str.lower()是一对方法，能够将字符串的英文字符变成小写或大写。

str.split(sep)是一个十分常用的方法，她能够根据sep分割字符串 str。str不是必须的，默认采用空格分隔，sep可以是单个字符，也可以是一个字符串，分割后的内容以列表形式返回。

str.count(sub)方法返回字符串str中出现sub的次数，sub是一个字符串。

---

类型判断和类型间转换

隐式类型转换：

数值运算操作符可以隐式的转换输出结果的数字类型，例如，两个整数采用运算符’/‘的出发将可能输出浮点数结果。

显示类型转换：

通过类型转换函数可以显式地在数字类型之间进行转换。

函数	描述
int（x）	将x转化为整数，x可以是浮点数或字符串
float（x）	将x转换为浮点数，x可以是整数或字符串
str（x）	将x转换为字符串，x可以是整数或浮点数

浮点数转换为整数类型时，小数部分会被舍弃掉（不适用四舍五入）。整数转换成浮点数类型时，会增加小数部分

---

凯撒密码

采用了替换方法将信息最中的每一个英文字符循环替换为 字母表序列中该字符的第三个字符，即循环右移3位，对应关系如下：

原文	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
密文	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	A	B	C

原文字符P，其密文字符C满足如下条件:

C=（P+3）mod26

解密方法之一

P=(C-3)mod26

凯撒密码包括加密部分和解密部分。

凯撒密码的加密算法程序首先接受用户输入的文本，然后对字母a-z和字母A-Z按照密码算法进行转换，同时输出。其他非英文字母部分直接输出

加密：

ptxt=input('请输入明文文本:')
for i in ptxt:
    if 'a'<=i<='z':
        print(chr(ord('a')+(ord(i)-ord('a')+3)%26),end='')
    elif 'A'<=i<='Z':
        print(chr(ord('A')+(ord(i)-ord('A')+3)%26),end='')
    else:print(i,end='')

解密：

ptxt=input('请输入密文文本:')
for i in ptxt:
    if 'a'<=i<='z':
        print(chr(ord('a')+(ord(i)-ord('a')-3)%26),end='')
    elif 'A'<=i<='Z':
        print(chr(ord('A')+(ord(i)-ord('Z')-3)%26),end='')
    else:print(i,end='')

二版本凯撒密码沿用了凯撒密码的思想，进一步使用字母表循环左移13位，因为一共是26个英文字母，从而使这一代码既可以用于加密算法，也可以以作为解密算法。

原文

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

左移

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

A

B

C

D

E

F

G

H

I

J

K

L

M

凯撒密码加密的思想也适用于中文字符，可以采用简化的unicode码右移三位。字母依然按照凯撒密码加密方式加密

 

程序的分支结构

单分支结构：if

单分支结构的语法：

if 条件：

语句块

条件是一个产生True或False结果的语句，当结果为True时，执行语句块，否则跳过语句块。缩进的语句块与if是包含关系。（语句块可以是一条语句，也可以是多条 语句）

如果条件是多个，多个条件间采用and或or进行逻辑组合。and表示多个条件”与“的关系，or表示多个条件”或“的关系 。

二分支结构：if-else

python中的二分支结构使用if……else对条件进行判断，其中if……else和语句块前的缩进都是语法的一部分 。语句块1在 if中条件为True时执行，语句块2在if中条件为False时执行。简单地说二分之结构根据条件的True或False结果产生两条路径。

if 条件：

语句块1

else：

语句块2

二分支结构还有一种简洁的表达方式，简称条件表达式。对于简洁表达方式，要使用表达式而不是语句

语法结构为：
表达式1 if 条件 else 表达式2

表达式和语句的区别：

表达式是产生或计算新数据值的代码片段 ，他并不是完整语句。例如 99+1是表达式，

a=99+1则是语句。

**多分支结构：**if-elif-else

多分支结构是一种多选一执行的结构，根据不同条件的结果按照顺序选择执行路径。常用于判断同一个条件的多个执行中经，python会按照代码顺序依次评估判断条件，寻找并执行第一个结果为True条件对应的语句块，当前语句块执行后会跳过整个if-elif-else结构。如果没有任何条件成立，else下面的语句块被执行，else子句是可选的。

if 条件 1：
语句块1

elif 条件2：

语句块2

……

else：

语句块N

利用多分支结构编写代码时要注意多个逻辑条件的先后关系。

---

判断条件及组合

分支结构中的判断条件可以使用任何能够产生True或False的语句或函数。形成判断条件最常见的方式是采用关系操作符。

操作符	操作符含义
<	小于
<=	小于等于
>=	大于等于
>	大于
==	等于
!=	不等于

任何非零的数值，非空的数据类型的布尔值为True，0或空类型的布尔值为False。

python语言中使用not，not和or对条件进行逻辑运算或组合。

not表示单个条件的“否”关系。

and表示多个条件之间的“与”关系

or表示多个条件之间的“或”关系

多条件之间可以通过小括号进行组合，实现条件之间的运算。

---

遍历循环使用保留字for依次提取遍历结构各元素进行处理：无限循环使用保留字while根据判断条件执行程序

循环

遍历循环for

for循环的语法结构：

for 循环变量 in 遍历结构：

语句块

遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的玄幻执行次数是根据遍历结构中元素的个数确定的。

遍历结构可以是字符串、文件、range（）函数或组合数据类型等

遍历字符串：

for 循环变量 in 字符串变量：

语句块

使用range（）函数，可以指定语句块的循环次数：

for 循环变量 in range（循环次数）：

语句块

遍历循环还有一种扩展模式 ，for——else结构。当for循环正常执行之后，程序会继续 执行else语句中的内容。else语句只在循环正常执行之后才执行结束。

---

无限循环：while

通过保留字while实现无限循环。

while 条件：

语句块

条件与if语句中的判断条件一样，结果为True和False

当程序执行到while语句时，判断条件如果为True，执行循环体语句，语句结束后返回再次判断while语句的条件：当条件为False时，循环 终止，执行while同级别缩进的后续语句。

无限循环也有一种else的扩展模式：
while 条件：
语句块1

else：

语句块2；

当while循环正常结束之后，程序会继续执行else语句中内容。els语句只在循环正常执行后才执行。

---

循环控制：break和continue

循环结构 有两个辅助循环控制的保留字：break与continue

break用来跳出最内层for或while循环，脱离该循环后程序继续执行循环后续代码。

如果有两层或多层循环，break跳出最内层循环

continue用来结束当此循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

区别为continue只结束本次循环，不终止整个循环的运行，而break具备结束整个当前循环的能力。

在while或for循环语句中使用了break退出循环，那么else语句将不再执行。

---

程序的异常处理

使用try-except进行异常处理

语法格式；

try：语法块1

except：

语法块2

程序也可以结合特定的错误类型进行处理。在except后指明错误类型，对于除零错误，可以在except后面增加ZeroDivisionError，仅指定处理该类型错误，再增加except处理其余错误。

try:
    for i in range(5):
        print(10/i,end='')
except ZeroDivisionError:
    print('除数为零，产生了除零错误')
except:
    print('某种原因，出错了')
#除数为零，产生了除零错误

---

函数

函数的基本使用

函数是一段具有特定功能的，可重用的语句组，通过函数名来表示和调用。经过定义 ，一组语句等于一个函数，在需要使用这组语句的地方，直接调用函数名称即可。因此，函数包括两部分：函数的定义和函数的使用。

使用函数主要有两个目的：降低编程难度和增加代码复用。函数是一种功能抽象，利用它可以将一个复杂的大问题分解成一系列简单的小问题，分而治之，为每个小问题编写程序，通过函数封装，解决问题。函数可以在一个程序中多个位置使用，也可以用于多个程序，当需要修改代码时，只需要在函数中修改一次，所有调用位置的功能都更新了这种代码复用降低了代码行数和维护难度

---

函数的定义

通过def关键字定义函数

语法格式：

def 函数名 （参数列表）:

函数体

return 返回值列表

函数名可以是任何有效的python标识符，参数列表是调用该函数时传递给它的值，可以有零个一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。参数列表中参数都是形式参数，相当于之际参数的一种符号表示或符号点位符。函数体是函数每次被 调用时执行的代码，由一行或多行语句组成。如果需要返回值，使用保留字return和返回值列表，函数可以没有return语句，函数体结束后会将控制权返回给调用者

def fact(n):
    s=1
    for i in range(1,n+1):
        s*=i
    return s

当函数没有return时，仅表示执行一段代码功能

---

函数的使用

函数的定义也叫函数声明，定义后的函数不能直接运行，需要经过“调用”才能得到运行

def fact(n):
    s=1
    for i in range(1,n+1):
        s*=i
    return s
print(fact(20))
#2432902008176640000

每次使用函数可以提供不同参数作为输入，以实现对不同数据的处理；函数执行后，可以反馈相应的处理结果。函数的执行与黑盒类型，使用者不需要了解函数内部实现原理，只要了解函数的输入输出方式即可

函数的使用一般分为四个步骤

1. 函数定义：
   使用def保留字符家那个一段代码定义为函数 ，需要确定函数名、参数名、参数的个数，使用参数名称作形式参数（占位符）编写函数内部的功能代码。
2. 函数调用：
   通过函数名调用函数功能，对函数的各个参数赋予实际值，实际值可以是实际数据，也可以是在调用函数前已经定义过的变量。
3. 函数执行：
   函数被调用后，使用实际参数（赋予形式参数的实际值）参与函数内部代码的运行，如果有结果则进行输出。
4. 函数返回：
   函数执行结束后，根据return保留字的指示决定是否返回结果，如果返回结果，则结果将被放置到函数被调用的位置，函数使用完毕，程序继续运行。

编程中大量使用函数已经成为一种编程范式，叫做函数式编程。函数式编程的主要思想是把程序过程尽量写成一系列函数调用，这能够使代码编写更简洁、更易于理解，是中小规模软件项目中最常用的编程方式

在python中，函数也是有类型的，可以通过type（）获得函数的类型。函数采用其定义的名字表达，具体为function类型，这是一种python的内置类型。然而，如果调用函数，则类型为返回值的类型。

py语言最小函数可以不表达任何功能，

def f（）：

pass

其中，保留字pass表示不进行任何操作，起到占位符的作用，因为函数体内部总要编写一行代码，对f（）的调用不实现任何功能

---

函数的参数传递

可选参数传递

函数的参数在定义时可以指定默认值，当函数被调用时，如果没人传入对应的参数时，则使用函数定义时的默认值代替

语法格式：

def 函数名（非可选参数列表，可选参数列表=默认值）：

函数体

return 返回值列表

def multiply(x,y=10):
    print(x*y)
multiply(99)   #990
multiply(99,2)       #198

需要注意，可选参数一般 都放置在非可选参数的后面，即定义函数时，先给出所有非可选参数，然后再分别列出每个可选参数及对应的默认值

---

参数名称传递

函数调用时，默认采用按照位置顺序的方式传递给函数，例如multiply（99，2）中第一个实参，默认赋值给形参x，第二个实参赋值给形参y

python支持函数按照参数名称方式传递参数

语法格式

函数名（参数名=实际值）

def multiply(x,y=10):
    print(x*y)
multiply(99)   #990
multiply(y=2,x=99)       #198

采用函数名传递方式不需要保持参数传递的顺序，参数之间的顺序可以任意调整，只需要对每个必要参数赋予实际值即可，这种方式会显著增强程序的可读性。

---

函数的返回值

return 语句用来结束函数并将子程序返回到函数调用的位置继续执行。return语句可以出现在函数中的任何部分，同时可以将0个、1个或多个函数运算的结果返回给函数被调用处的变量

def multiply(x,y=10):
    return x*y
s=multiply(99,2)
print(s)     #198

多个返回值问题

当return返回多个值时，这些值形成了一个元组数据类型，由小括号和逗号分隔，例如（a，b，c）。元组是python内置的一种组合数据类型，

函数可以没有return，此时函数并不返回值

def printword():
    print("这是一个没有return的函数")
printword()   #这是一个没有return的函数

当函数使用return返回多个值时，可以使用一个变量或多个变量保存结果。

def multiply(x,y=10):
    return x*y,x+y
s=multiply(99,2)
print(s)     #(198, 101)
a,b=multiply(99,2)
print(a)    #198
print(b)    #101
print(type(s))  #<class 'tuple'>
print(type(a))   #<class 'int'>
print(type(b))   #<class 'int'>

当函数存在多种结束条件时，将使用多个return语句。

def manyret(x):
    try :
        if x>0:
            return x+1
        else:
            return x-1
    except:
        return 0
print(manyret(10))           #11
print(manyret(-10))          #-11
print(manyret('python'))     #0

在manyret（）函数中，由于存在try-except异常判断及if-else分支语句。该函数有3个出口，即3个返回return语句。这种情况在函数运行中十分常见

 format()方法的基本使用

字符串格式化指的是用于解决字符串和变量同时输出的格式安排问题。

语法格式：

模板字符串.format(逗号分割的参数)

模板字符串是一个字符串和槽组成的字符串，用来控制字符串和变量的显示效果，槽用{}表示，对应format（）方法中逗号分隔的参数

print('{}曰:学而时习之,不亦说乎'.format('孔子'))
#孔子曰:学而时习之,不亦说乎

如果模板字符串有多个槽，且槽内没有指定序号，则按照槽出现的顺序分别对应.format()方法中的不同参数。

print('{}曰:学而时习之,不亦{}'.format('孔子','说乎'))
#孔子曰:学而时习之,不亦说乎

format()方法中参数根据出现先后存在一个默认序号:

print('{0}曰:学而时习之,不亦{1}'.format('孔子','说乎'))
#孔子曰:学而时习之,不亦说乎

print('{1}曰:学而时习之,不亦{0}'.format('说乎','孔子'))
#孔子曰:学而时习之,不亦说乎

print('{0}开{0}落'.format('花'))
#花开花落

---

format方法的格式控制

format（）方法的槽除了包含参数序号，还可以包括格式控制信息，格式控制标记用来控制参数显示时的格式

语法格式：

(参数序号:格式控制标记)

：	填充	对齐	宽度	,	精度	类型
引号 符号	用于填充的单个字符	<左对齐 >右对齐 ^居中对齐	槽的设定 输出宽度	数字的千位分隔符，适用于整数和浮点数	浮点数小数部分的精度或这符串的最大输出长度	整数类型b,c,d,o,x,X浮点数类型e,E,f,%

用于显示格式的规范:

1. 宽度：指当前槽的设定输出字符宽度，如果实际值比宽度设定的值大，则使用实际长度，实际宽度小于指定宽度，则按照指定方式在宽度内对齐，默认左对齐以空格字符填充
2. 对齐：默认左对齐
3. 填充：默认是空格字符串填充，填充字符串只能有一个。

>>> '{0:25}'.format('等级考试')
'等级考试                     '
>>> '{0:^25}'.format('等级考试')
'          等级考试           '
>>> '{0:*^25}'.format('等级考试')
'**********等级考试***********'
>>> '{0:*>25}'.format('等级考试')
'*********************等级考试'
>>> '{0:*>1}'.format('等级考试')
'等级考试'

对用于对数值本身的规范:

1. 逗号( , ) : 用于显示数字类型的千位分隔符。
2. .精度：由小数点开头（ . ）, 对于浮点数，精度表示小数部分输出的有效位数，对于字符串.精度表示输出的最大长度。如果小数点保留长度超过应输出的长度的，以应输出长度为准。

>>> '{:.2f}'.format(12345.67890)
'12345.68'
>>> '{:-^25,}'.format(1234567890)
'------1,234,567,890------'
>>> '{:.2f}'.format(12345.67890)
'12345.68'
>>> '{:>25.3f}'.format(12345.67890)
'                12345.679'
>>> '{:.5}'.format('全国计算机等级考试')
'全国计算机'
>>> '{:.15}'.format('全国计算机等级考试')
'全国计算机等级考试'

类型:表示输出整数和浮点数类型的格式规则

1. **整数类型输出格式：
   **b：输出整数的二进制方式
   c：输出整数对应的Unicode字符
   d：输出整数的十进制方式
   o：输出整数的八进制方式
   x：输出整数的小写十六进制方式
   X：输出整数的大写十六进制方式
2. **浮点数类型输出格式：
   **e：输出浮点数对应的小写字母e的指数形式
   E：输出浮点数对应的大写字母E的指数形式
   f：输出浮点数的标准浮点形式
   %：输出浮点数的百分比形式

>>> '{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}'.format(425)
'110101001,Ʃ,425,651,1a9,1A9'
>>> '{0:e},{0:E},{0:f},{0:%}'.format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'
>>> '{0:.2e},{0:.2E},{0:.2f},{0:.2%}'.format(3.14)
'3.14e+00,3.14E+00,3.14,314.00%'

---

变量 

变量的作用域

根据程序中变量所在的位置和作用范围，变量可分为局部变量和全局变量。局部变量仅在函数内部，且作用域也在函数内部。全局变量的作用域跨过多个函数

局部变量

局部变量指在函数内部定义的变量，仅在函数内有效，当函数退出时变量将不再存在

变量z是函数multiple（）内部使用的变量，当函数调用后，变量z 将不存在

def multiply(x,y=10):
 z=x+y
 return z
s=multiply(99,2)
print(s)    #101
print(z)
'''
Traceback (most recent call last):
 File "E:\pycharm\PyCharm Community Edition 2020.3.2\练习.py", line 6, in <module>
 print(z)
NameError: name 'z' is not defined
'''

全局变量

全局变量指在函数之外定义的变量，在程序执行全过程有效。全局变量在函数内部使用时，需要提前使用保留字global声明。

语法格式：

global 全局变量

n=2
def multiply(x,y=10):
    global n
    return x*y*n
s=multiply(99,2)
print(s)    #396

使用global对 全局变量声明时，该变量要与外部全局变量同名。

上例中，变量是全局变量，在函数multiply（）中使用时需要在函数内部使用global声明，声明后即可使用。如果未使用保留字global声明，即使名称相同，也不是全局变量

n=2
def multiply(x,y=10):
     n=x*y
     return n
s=multiply(99,2)
print(s)    #396
print(n     #2

组合数据类型基本概念

最常用的组合数据有3大类。分别是集合类型、序列类型和映射类型。

集合类型是一个元素融合，元素之间无序，相同元素在集合中唯一存在

序列类型是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他。序列类型的典型代表是字符串类型和列表类型

映射类型是“键-值”数据项的组合，每个元素是一个键值对，表示 （key，value）。映射类型的典型代表是字典类型

集合类型是一个具体的数据类型名称，而序列类型和映射类型是一类数据类型的总称。

---

集合类型描述

与数学中的集合概念一致，包含0个或多个数据项的无序组合。集合是无序组合，用大括号{}表示，他没有索引和位置的概念，集合中的元素可以同台增加或者删除。

集合中的元素不可重复，元素类型只能是不可变数据类型，不能作为集合中的元素出现。

>>> s={1010,'10101',98.5}
>>> type(s)
<class 'set'>
>>> len(s)
3
>>> print(s)
{1010, '10101', 98.5}

注意事项：由于集合元素是无序的，集合的输出顺序与 定义顺序可以不一致。

由于集合元素独一无二，使用集合类型能够过滤掉重复元素

由于集合元素是无序的，所以集合元素间没有顺序，不能比较，不能排序。创建集合直接输用{}。

>>> s={1010,'1010',123}
>>> s
{1010, 123, '1010'}
>>> s={1010,'1010',123,1010,1010}
>>> s
{1010, 123, '1010'}

操作符及运算	描述
S-T	返回一个新集合，包括在集合S中但不在集合T中的元素
S&T	返回一个新集合，包括同时在集合S和T中的元素
S^T	返回一个新集合，包括集合S和T中非共同元素
S|T	返回一个新集合，包括集合S和T中所有元素

上述操作符表达了集合类型的4种基本操作，交集（&）、并集（|）、差集（-）、补集（^），操作逻辑与数学定义相同。

>>> s={1,2,3}
>>> t={3,4,5}
>>> print('交集',s&t)
交集 {3}
>>> print('并集',s|t)
并集 {1, 2, 3, 4, 5}
>>> print('补集',s^t)
补集 {1, 2, 4, 5}
>>> print('差集',s-t)
差集 {1, 2}

函数或方法	描述
s.add(x)	如果数据项x不在集合s中，将x增加到s
s.remove(x)	如果数据项x在集合s中，移除该元素，不在则产生keyError的异常
s.clear(x)	移除s中的所有数据项
len(s)	返回集合s的元素个数
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False

set（x）函数将其他的组合类型变成 集合类型，返回结果是一个无重复且排序任意的集合。set（）函数也可以生成空集合变量

---

序列类型概论

序列类型是一堆元素向量，元素之间存在先后关系，通过序号访问。序列的基本塑像和表示方法均来源于数学概论。在数学中，经常给每个序列起一个名字，例如。n个数的序列s，可以表示为：
s=s0，s1，s2，……，sn-1

当需要访问序列中的某个特定值时，只需要通过下标标出即可。例如，需要找到序号为2的元素，即可通过s{2}获得。注意，序列的下标从0开始编号。

由于元素之间存在顺序关系，所以序列中可以存在数值相同但位置不同的元素。python语言中有很多数据类型都是序列类型，其中比较重要的是字符串类型、列表类型和元组类型。

字符串类型可以看成是单一字符串的有序集合，属于序列类型。列表则是一个可以使用多种类型元素的序列类型。

序列类型各个具体类型使用相同的索引体系，与字符串类型一致，即正向递增序号和反向递增序号

操作符	描述
s+t	连接s和t
s*n或n*s	将序列s或n复制n或s次
s[ i ]	索引，返回序列的第 i 个元素
s[ i : j ]	切片，返回包含序列s的第 i 到 j 个元素的子序列（不包含第 j 个元素）
s[ i : j : k ]	步骤切片，返回包含序列s的第 i 到 j 个元素以 k 为步骤的子序列
len（s）	序列s的元素个数
min（s）	序列s中的最小元素
max（s）	序列s中的最大元素
s . index( x)	序列s中第一次出现x的位置
s.count(x)	序列s中出现x的总次数

元组类型是序列类型的重要组成之一。元组类型在python中表示为typle。一般以小括号和逗号进行组织

元组类型严格遵循序列类型的操作定义，可以使用序列类型的操作符含函数

元组类型一旦定义就不能修改，在编程中不够灵活，同时，元组类型的所有操作都可以由列表类型实现。因此，一般编程中，如果需要自定义变量，通常以列表类型代替元组类型使用。如果确认编程中不需要修改顺序，可以使用元组类型。

主要在语法相关的场景使用，当返回多个值时，多个返回值以元组类型返回，实际上返回一个数据类型。

>>> def f(x):
        return x,x+1,x+2
>>> f(1)
(1, 2, 3)
>>> type(f(1))
<class 'tuple'>
>>>

---

映射类型概述

映射类型是“键-值”数据项的组合，每个元素是一个键值对，即元素是（key，value），元素之间是无序的。键值对（key，value）是一种二元关系，源于属性和值的映射关系。

映射类型是序列类型的一种扩展。在序列类型中，采用从0开始的正向递增序号进行具体元素值的索引。而映射类型则由用户来定义符号，即键，用其去索引具体的值。

键（key）表示一个属性，也可以理解为一个类别或项目，值（value）是属性的内容，键值对刻画了一个属性和它的值。键值对将映身关系结构化，用于存储的感知和表达

---

列表类型

列表类型是包含0个或多个元素的有序序列。属于序列类型。列表可以进行元素的增加、删除、替换、查找等操作。列表没有长度限制。元素类型可以不同，不需要预定长度。

列表类型用中括号 {}表示，也可以通过list（x）函数将集合或字符串类型转换成列表类型。list（）函数可生成空列表。

>>> lst=[1010,'1010',[1010,'1010'],1010]
>>> lst
[1010, '1010', [1010, '1010'], 1010]
>>> list('全国计算机等级二级考试')
['全', '国', '计', '算', '机', '等', '级', '二', '级', '考', '试']
>>> list()
[]

列表属于序列类型，列表支持序列类型对应的操作

---

列表的索引

索引是列表的基本操作，用于获得列表听一个元素。该操作沿用序列类型的索引方式，即正向递增序号和反向递减序号，使用中括号作为索引操作符，索引序号不能超过列表的元素范围，否则会产生IndexError的错误

可以使用遍历循环对列表类型的元素进行遍历操作：
语法格式：

for 循环变量 in 列表变量：

语句块

---

列表的切片

切片是列表的基本操作，用于获得列表的一个片段，即获得零个或多个元素。切片后的结果也是列表类型。切片有两种使用方式：

列表或列表变量[ N : M ]

列表或列表变量[ N : M : K ]

在 [ ] 中表示区间需要使用冒号（：）如切片：表示枚举使用逗号（，），如列表

切片获取列表类型从N到M（不包括M）的元素组成新的列表，其中，N和M为列表类型的索引序号，可以混合使用正向递增序号和递减序号，一般要求N小于M。当N大于等于M时，返回空列表。当K不存在时，切片获取列表类型从N到M(不包括M)以K为步长所对应元素组成的列表

>>> l=[1,2,[3,4],5]
>>> l[1:4]
[2, [3, 4], 5]
>>> l[-1:-3]
[]
>>> l[-3:-1]
[2, [3, 4]]
>>> l[0:4:2]
[1, [3, 4]]
>>>

---

列表的操作函数

操作函数	描述
len(lst)	列表lst元素个数
min(lst)	列表lst中的最小元素
max(lst)	列表lst中的最大元素
list(x)	将x转变成列表类型

>>> l=[1,[2,[3,[4,5]]]]
>>> len(l)
2

---

列表的操作方法

列表类型存在一些操作方法。

语法格式为：

列表对象 . 方法名（参数列表）

方法	描述
lst.append()	在列表lst最后增加一个元素x
lst.insert(i,x)	在列表lst第[ i ]个位置增加元素x
lst.clear()	删除lst中所有元素
lst.pop（i）	将列表lst中出现的第i项元素取出，并从lst中删除该元素
lst.remove(x)	将列表中出现的第一个元素x删除
lst.reverse()	将列表lst中的元素反转
lst copy()	生成一个新列表，复制lst中所有的元素

列表的方法主要针对列表对象 ，实现列表的元素的增、删、改等功能

lst.append(x)在列表lst的最后增加一个元素，如果希望增加多个元素，可以使用加号，将两个列表合并。

>>> l=[1010,'10.0','hello']
>>> l.append('world')
>>> print(l)
[1010, '10.0', 'hello', 'world']
>>> l.append([1001,'python'])
>>> print(l)
[1010, '10.0', 'hello', 'world', [1001, 'python']]

还可以使用del对列表元素或片段进行删除。

语法格式：
del 列表对象[ 索引序号 ]

del 列表对象[ 索引起始 ：索引结束 ]

del 列表对象[ 索引起始 ：索引结束 ：步长]

lst.reverse()将列表list中元素进行逆序反转。

lst.copy()复制lst中所有元素生成一个新列表。

>>> l=[1,2,3,4,5]
>>> l2=l.copy()
>>> l.clear()
>>> print(l2)
[1, 2, 3, 4, 5]
>>> print(l)
[]

一个列表使用copy（）方法复制后赋值给变量list2，将list元素清空不影响新生成的变量list2.如果不使用.copy()方法，通过直接赋值方法不能产生新列表，仅能够成为列表增加一个别名。

>>> l=[1,2,3,4,5]
>>> l2=l
>>> l.clear()
>>> print(l)
[]
>>> print(l2)
[]

---

字典类型

字典的定义

”键值对“是组织书许多一种重要方式，广泛应用在当代大型信息系统中，如web系统。键值对的基本思想是将”值“信息关联一个”键“信息，进而通过键信息找对应的值信息，这个过程叫映射。py通过字典实现映射

字典使用大括号{}建立，每个元素是一个键值对。

语法格式：

{键1：值1，键2：值2，键3：值3，……，键N：值N}

其中，键和值 通过冒号链接，不同键值对通过逗号隔开。从py设计角度考虑，由于大括号可以表示集合，所以字典也有类似集合的性质，即键值对之间没有顺序，不能重复。可以把字典看成元素是键值对的集合。但集合与字典是不同的类型

字典类型和集合类型形式上都采用大括号表示，但如果 直接使用大括号{}，则生成字典类型，而不是集合类型

>>> d={}
>>> type(d)
<class 'dict'>
>>> s=set()
>>> type(s)
<class 'set'>

字典的索引

索引是按照一定顺序检索内容的体系。列表类型采用元素顺序的位置进行索引。由于字典元素”键值对”中键是值的索引，因此，可以直接利用键值对关系索引元素。

字典中键值对的索引语法

值=字典对象 [ 键 ]

利用索引和赋值配合，可以对字典中每个元素进行修改。

>>> d={'202001':'张三','202002':'李四','202003':'王五'}
>>> d['202003']='陈六'
>>> print(d)
{'202001': '张三', '202002': '李四', '202003': '陈六'}

通过大括号 {}可以创建字典，可以创建一个空字典 。通过索引和赋值配合，可以向字典中增加元素

>>> d={}
>>> d['202004']='小新'
>>> print(d)
{'202004': '小新'}

字典是储存可变数据量键值对的数据结构，键和值可以是任意数据类型，通过键索引值 ，并可以通过建修改值

操作函数	描述
len()	字典d的元素个数
min()	字典d中键的最小值
max()	字典d中键的最大值
dict()	生成一个空字典

len（d）给出字典d的元素个数,也称为长度。

min（）和max（）分别返回字典d中最小值或最大值索引值，使用这两个函数的前提是字典中各索引元素可以进行比较。

字典的操作方法

语法格式为：

操作方法	描述
d.key()	返回所有的键信息
d.values()	返回所有的值信息
d.item()	返回所有的键值对
d.get(key,default)	键存在则返回相应值,否则返回默认值 default
d.pop(key,default)	键存在则返回相应值,同时删除键值对，否则返回默认值default
d.popitem	随机从字典中取出一个键值对，以元组（key，default）形式返回，同时将该键值对从字典中删除
d.clear	删除所有的键值对，请空字典

字典类型也支持保留字in，用来判断一个键是否在字典中，如果在，则返回True。否则返回False。

字典可以遍历循环对其元素进行遍历。

语法结构：
for 变量名 in 字典名称：

语句块

由于键值对中的键可以相当于索引，所以，for循环返回的变量名是字典的索引值。如果需要获取键对应的值，可以在语句块中通过gte（）方法获得

d={'202001':'张三','202002':'李四','202003':'王五'}
>>> for i in d:
    print(i,':',d.get(i))
202001 : 张三
202002 : 李四
202003 : 王五

文件

文件是存储在辅助存储器上的一组数据序列，可以包含任何数据内容。概念上，文件时数据的集合和抽象。文件包含文本文件和二进制文件两种类型。

文件的类型

文本文件一般由单一特定编码的字符组成。如UFT-8编码，内容容易统一展示和阅读 。大部分文本文件都可以通过文本编程软件或文字处理软件创建、修改和阅读。由于文本文件存在编码，所以，它也可以被看作是存储在磁盘上的长字符串，如一个txt格式的文本文件。

二进制文件直接由比特0和比特1组成，没有统一的字符编码。文件内部数据的组织格式与文件用途有关，二进制是信息按照非字符串但有特定格式形式的文件，如png格式的图片文件、avi格式的视频文件。二进制文件和文本文件最主要的区别在于是否有统一的这符编码。二进制文件没有统一的字符编码，只能当作字节流，而不能看作是字符串。

无论文件创建为文本文件或者是二进制文件，都可以用“文本文件方式”和“二进制文件方式”打开，但打开后的操作不同。

一个文本文件a.txt.。其内容为“全国计算机等级考试”，采用文本方式打开。这里需要将文本文件与python程序文件放在同一文件夹中

---

文件的打开和关闭

python对文本文件和二进制文件采用统一的操作步骤，即”打开-操作-关闭“，操作系统中的文件默认处于储存状态，首先需要将其打开，使用得当前程序有权操作这个文件，打开不存在的文件系统可以创建这个文件。打开后的文件处于占用状态，此时，另一个进程不能操作这个文件，可以通过一组方法读取文件的内容或向文件写入内容，操作之后需要将文件关闭，关闭将释放对文件的控制使用文件恢复成储存状态，此时，另一进程能够操作这个文件。

python通过open（）函数打开一个文件，并返回一个操作这个文件的变量。

语法结构：

变量名=open（文件路径及文件名，打开模式）

open()函数有两个参数：文件名和打开模式。文件名可以是文件的实际名字，也可以是包含完整路径的名字 。打开模式用于控制使用何种方式打开文件，open（）函数提供了7种基本的打开模式。

打开模式	含义
r	只读模式，如果文件不存在，返回异常FlieNotFoundError，默认值
w	覆盖写模式，文件不存在则创建，存在则完全覆盖原文件
x	创建写模式，文件不存在则创建，存在则返回异常FlieExistsError
a	追加写模式，文件不存在则创建，存在则在源文件子厚追加内容
b	二进制文本模式
t	文本文件模式，默认值
+	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

打开模式使用字符串方式表示，根据字符串定义，单引号或者双引号均可。上述打卡爱模式中r，w，x，a可以和b，t，+组合使用，形式即表达读写又表达文件模式的方法。

打开文件有一些常用组合，使用方法如下：

1. 以文本方式只读打开一个文件，读入后不能对文件进行修改
   变脸名=open（文件名，‘r’）
   变量名=open（文件名）
2. 以文本方式可读写的打开一个文件，可以读入并修改文件
   变量名=open（文件名，‘r+’）
3. 以文本方式打开一个空文件，准备写入一批内容，并保存为新文件
   变量名=open（文件名，‘w’）
4. 以文本方式打开一个空文件或已有文件，追加形式写入一批内容，更新原文件
   变量名=open（文件名，‘a+’）
5. 以二进制方式只读打开一个文件或已有文件，追加形式写入一批内容，更新原文件
   变量名=open（文件名，‘rb’）
6. 文件使用结束后要用close（）方法关闭，释放文件的使用权
   变量名 . close()

---

文件的读写

根据打开方式不同，文件读写也会根据文本文件或二进制打开方式有所不同。

方法	含义
f.read(size=-1)	从文件中读入一行内容。参数可选，如果给出，读入前的size长度的字符串或字节流
f.readline(size=-1)	从文件中读入一行内容。参数可选，如果给出，读入该行前的size长度的字符串或字节流
f.readlines(hint=-1)	从文件中读入所有行，以每行为元素形成一个列表。参数可选，如果给出，读入hint行
f.seek(offset)	改变当前文件操作指针的位置，offset的值：0为文件开头：2为文件结尾。

如果文件以文本 文件方式打开，则读入字符串：如果文件以二进制方式打开，则读入字节流。

如下是一个文件 的内容，保存为 bar.txt，存储路径是windows目录下D盘根目录。对bar.txt文件的读入实例如下。

如果文件不大，可以 一次性将文件内容读入，保存到程序内部变量中。f.read()是最常用的一次性读入文件的函数，其结果是一个字符串

文件打开后，对文件的读写有一个读取指针，当从文件中读入内容后，读取指针将向前进，再次读取的内容将从只针对新位置开始。

结合读取指针理解，上述代码中lst返回服务回购空，因为之前f.read()方法已经读取了文件全部内容，读取指针在文件末尾，再次调用f.readlines()方法无法从当前读取指针处输入内容，因此返回结果为空。

f.seek()方法能够移动读取指针的位置，f.seek(0)将读取指针移动到文件开头。f.seek(2)将读取指针移动到文件结尾。

从文本文件中逐行读入内容并进行处理是一个基本的文件操作需求。稳不稳文件可以看作是由行组成的组合类型，因此，可以使用遍历循环逐行遍历文件。

语法格式：

f=open（文件路径及名称，‘r’）

for line in f:

print (line)

f.close(）

方法	含义
f.write(s)	向文件写入一个字符产或字节流
f.writelines(lines)	将一个元素为字符串的列表整体写入文件

f.write(s)向文件写入字符串s，每次写入后，将会记录一个写入指针。该方法可以反复调用，再写入指针后分批写入内容，直至文件被关闭。

使用f.write(s)时，要显示的使用“/n”对写入文本进行分行，如果不进行分行，每次写入的字符串会被连接起来。

f.writelines(lines)直接将列表类型的个元素连接起来写入文件f

---

数据组织的维度

一维数据

一维数据由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中数组的概念

储存方式有很多种

空格，逗号，换行，特殊字符

逗号分隔的储存格式叫做CSV格式，它是一种通用的、相对简单的文件格式，在商业和科学上广泛使用，大部分编辑器都支持直接读入或保存文件为CSV格式，如WINDOWS平台上的笔记本或微软Office等。储存文件一般采用.csv为扩展名

一维数据的处理

对一维数据进行处理首先需要从CSV格式文件读入一维数据，并将其表示为列表对象。

需要注意，从CSV文件中获得内容时，最后一个元素后面包含了一个换行符（“\n”）。对于数据的表达和使用来说，这个换行是多余的，需要采用strip（）方法去掉数据尾部换行符，进一步使用split（）方法以逗号进行分割

二维数据

也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵，常见的表格都属于二维数据

二维数据的处理

二维数据可以用二位列表俩表示，即列表的每个元素对应二维数据的一行，这个元素本身也是列表类型。

对二维数据进行处理首先需要从CSV格式文件读入二维数据，并将其表示为二维列表对象。

二维数据处理等同于二位列表的操作。与一维列表不同，二维列表一般需要借助循环遍历实现对每个数据的处理。

语法结构：
for row in lst:
for item in row:

对第row行第item列进行处理

二维数据的储存

二维数据由一维数据组成，用CSV格式文件存储。CSV文件的每一行是一维数据，整个CSV文件是一个二维数据。存储以下数据为.csv文件，

高维数据

由键值对类型的数据构成，采用对象方式组织，可以我层嵌套。

高维数据在web系统中十分常用，作为当今Internet组织内容的主要方式，高维数据衍生出Html、XML、JSON等具体世俗剧组知道语法结构。

 

计算生态

基本的python内置函数

abs(x)	x的绝对值，如果x是复数，返回复数的值
all(x)	组合类型变量x中所有元素都为真时返回True，否则返回False；若x为空，返回True
any(x)	组合类型变量x中任一元素为真时返回True，否则返回False；若x为空，返回True
bin(x)	将整数x转换为等值的二进制字符串，如bin（1010）的结果为0b1111110010
bool(x)	将x转换为Boolean类型，即True或False。如 bool（‘’）的结果时False
chr(x)	返回Unicode为i的字符。如chr（97）的结果是‘a’
complex(r,i)	创建一个复数r+i*1j,其中i可以省略 。如complex（10，10）的结果 是10+10j
dict()	创建字典类型。如dict（）的结果是一个空字典
divmod(a,b)	返回a，b的商和余数。如divmod（10，3）的结果是（3，1）
eval(s)	计算字符串s作为表达式 的值，如eval（‘1+99’）的结果是100
exec(s)	计算字符串s作为语句的值。如eval（‘a=1+99’）运行后，变量a的值为1000
float（x）	将x转换成浮点数，如float（1010）的结果是1010.0
hex（x）	将整数转换为十六进制字符串。如hex（1010）的结果是‘0x3f2’
input（x）	获取用户输入，其中s是字符串 ，作为提示信息。s可选
int（x）	将x转换成整数。如len（range（10））的结果是10
len(x)	计算变量
list（x）	创建或将变量x转换成一个列表类型。如list（{10，9，8}）的结果是[8,9,10]
max(a1,a2,……)	返回参数的最大值，如max（1，2，3，4，5）的结果是5
min(a1,a2,……)	返回参数的最小值，如min（1，2，3，4，5）的结果是1
oct(x)	将整数转换为八进制字符串。如oct（1010）的结果是‘0o1762’
pow(x,y)	返回x的 y次幂。如pow（2，3）的结果是8
print(x)	打印变量或字符串x。print（）的end参数用来表示输出的结尾字符串
range(a,b,s)	从a到b（不含b）以s为步长产生一个符号，如list（range（1，10，3））结果为[1,4,7]
reversed(r)	返回组合类型r的逆序迭代形式、如for i in reversed（[1,2,3]）:将逆序遍历列表
round(n)	四舍五入方式计算n。round（10，6）的结果是11
set(x)	将组合数据类型x转换成集合类型。如set([1,1,1])的结果为{1}
sorted(x)	对组合数据类型x进行排序,默认从小到大。sorted([1,3,5,2,4])结果为[1,2,3,4,5]
str(x)	将x转换为等值的字符串，如str（0x1010）的结果是‘4112’
sum(x)	对组合数据类型x计算求和结果。如sum{[1,3,5,2,4]}的结果是15
type(x)	返回变量x的数据类型。如type（{1：2}）的结果是<class 'dict'>

turtle标准库

turtle库绘制图形有一个基本框架；一个小海龟在坐标系中爬行。其爬行轨迹形成了绘制图形。

使用import保留字对turtle库的引用有以下三种方式；

import turtle，

对turtle库中函数调用采用turtle.函数名（）形式

form turtle import *，

则对 turtle库中函数调用直接采用函数名形式（），不再使用turtle作为前导。

import turtle as t

对turtle库中函数调用采用更简洁的t.函数名（）形式，保留字as的作用 是将turtle库给予别名t。此处也可以使用t之外的其他别名

---

窗体函数

turtle.setup()函数与窗体有关。

turtle.setup(width,height,startx,starty)

参数详解 ：

width:窗口宽度。如果值是整数，表示的是像素值：如果值是小数，表示窗口宽度与屏幕的比例。

height:窗口高度。如果值是整数，表示的是像素值：如果值是小数，表示窗口高度与屏幕的比例。

startx:窗口左侧与屏幕左侧的像素距离。如果值是None，窗口位于屏幕水平中央。

starty:窗口顶部与屏幕顶部的像素距离。如果值是None,窗口位于屏幕垂直中央。

函数	别名或使用	描述
pendown()	turtle.up() | turtle.pu()	放下画笔
penup()	turtle.pd() | turtle.down()	提起画笔，与pendown()配对使用
pensize()	turtle.width()	设置画笔线条的粗细为指定大小
pencolor()		设置画笔颜色
color()		设置画笔和填充颜色
begin_fill()		填充图形前，调用该方法
end_fill()		填充图形结束
filling()		返回填充的状态，True为填充，False为未填充
clear()		清空当前窗口，但不改变当前窗口的位置
reset()		清空当前窗口，并重置位置等状态为默认值
screensize()		设置画布窗口的宽度、高度和背景颜色
hideturtle()		隐藏画笔的turtle形状
showturtle()		显示画笔的turtle形状
isvisible()		如果turtle可见，返回True
write(str,font=None)		输出font字体的字符串

turtle.pencolor(colorstring) 或 turtle.pencolor((r,g,b))

colorstring表示颜色的字符串，例如“purple”，”red“等。

（r，g，b）：颜色对应的RGB的0~1数值，例如1，0.65，0

turtle.color(colorstring1，colorstring2) 或 turtle.color((r1,g1,b1)，(r2,g2,b2))

设置画笔和背景颜色，当无参数输入时返回当前画笔和背景颜色。

参数：colorstring1：表示颜色的字符串。

（r，g，b）：颜色对应的RGB的0~1数值，例如1，0.65，0

turtle.begin_fill()和turtle.end_fill()函数用来设置填充域色彩，这两个函数结对使用

在开始设置绘制填充背景图形前调用。

turtle.end_fill()的配对函数。在结束绘制拟填充背景图型后调用

turtle.filling()

返回当前图形背景颜色的填充状态，如果当前代码在begin_fill（）和end_fill(),之间则返回True、否则返回False。

turtle.clear()函数 清空当前窗口

turtle.clear()

清空当前绘制窗口，海归对象绘图位置和角度归为原点

turtle.screensize()函数设置画布窗口的宽度、高度和背景颜色。

设置当前画布窗口的宽度为width，高度为height，背景颜色为bgcolor，如果不给出参数，则以元组形式返回当前画布窗口的宽度和高度（width,height）

width:窗体的宽度，以像素为单位

height：窗体的高度，以像素为单位

bgcolor：表示颜色的字符串或颜色对应的RGB的0~1数值

turtle.hideturtle()

隐藏画笔的turtle形状

turtle.showturtle()

显示画笔的turtle形状

turtle.isvisible()

如果turtle画笔的形状显示，则返回True，否则返回False

turtle.write(str,font=None)

根据设置的字体 font形式，将字符串str显示在画布上

str：拟输出的字符串

font（字体名称、第题的尺寸和字体类型3个元素构成的元组）

---

画笔运动函数

forward(distance)	沿着当前方向前进指定距离
background(distance)	沿着当前相反方向后退指定距离
right(angle)	向右转angle角度
left(angle)	向左转angle角度
goto(x,y)	移动到绝对坐标(x,y)处
setx(x)	修改画笔横坐标到x，纵坐标不变
sety(y)	修改画笔纵坐标到y，横坐标不变
setheading(angle)	设置当前朝向为angle角度
home()	设置当前画笔位置为原点,朝向东
circle(radius,e，steps)	绘制一个指定半径r和角度e的圆或弧形
dot(r,color)	绘制一个指定半径r和颜色color的圆点
undo()	撤销画笔最后一部动作
speed()	设置画笔的绘制速度，参数为0-10之间

turtle.fd()函数最常用，他控制画笔向当前行进方向前进一格距离。

turtle.foward(distance)别名turtle.fd(distance)

distance行进距离的像素值，当值为负数时，表示向相反方向前进

turtle.backward(distance)别名turtle.bk

作用，向小海龟当前行进的相反的方向运动 ，当值为负值时，表示向前进方向运动

turtle.right(angle)

改变画笔行进方向为当前方向左侧angle度。angle是角度相对值。

参数：角度的整数值

turtle.left(angle)

改变画笔行进方向为左侧angle度。angle是角度 相对值

参数：角度的整数值

turtle.goto(x,y)移动画笔到画布中的特定位置，该位置以坐标(x,y)方式表达。如果当前画笔处于落下状态，则绘制当前位置到目标位置的线条。

参数：x画布中特定位置的横坐标

y：画布中特定位置的纵坐标

turtle.setx(x)

修改画笔的横坐标x，纵坐标不变

turtle.sety(y)

修改画笔的纵坐标，横坐标不变

turtle.setheading(angle)

设置小海龟当前行进方向to_angle，该角度是绝对方向角度值

turtle.home()

移动画笔到 坐标系原点，画笔方向为初始方向

turtle.circle(radius,e，steps)

根据半径radius绘制extent角度的弧形。当半径值为正数时，半径在小海龟左侧，当值为负数时，半径在小海龟右侧

entent：绘制弧形的角度，当不给该参数或参数为None时，绘制整个圆形

steps：起点到终点由steps条线组成

turtle.dot(r,color)

绘制一个带有背景色 color、直径为size的圆点

size圆点的直径，像素值

color：颜色字符串或rgb的0-1值，表示背景颜色

turtle.undo()

撤销绘图和最后一次动作

turtle.speed()

设置画笔的绘制速度，参数为0-10，0没有绘制动作，1-10逐步增加绘制速度，超过10则等同于参数为0，

---

random库

使用梅森旋转算法生成伪随机数序列

这个库提供了不同类型的随机数，其中最基本的函数是random.random()。它生成一个[0.0,1.0)之间的随机小数，所有其他随机数都是基于这个函数来的

seed(a=None)	初始化随机数种子，默认值为当前系统时间
random()	生成一个[0.0 , 1.0)之间的随机小数(0.0<x<1.0)
randint(a,b)	生成一个[a,b]之间的整数
getranddbis(k)	生成一个k比特长度的随机整数
randrange(start,stop,[step])	生成一个[start,stop]之间以step为步数的随机整数
unifom(a,b)	生成一个 [a,b]之间的随机小数
choice(seq)	从序列类型中随即返回一个元素
shuffle(seq)	将序列类型中元素随机排列，返回打乱后的顺序
sample(pop,k)	从pop类型中随机选取k个元素，以列表类型返回

随机数生成基于随机数种子，每个种子作为输入，利用算法生成一系列随机数，构成伪随机序列。random库使用random.seed(a)对后续产生成的随机数相同

>>> import random as r
>>> r.seed(10)
>>> r.random()
0.5714025946899135
>>> r.random()
0.4288890546751146
>>> r.seed(10)
>>> r.random()
0.5714025946899135
>>> r.random()
0.4288890546751146

---

time库

主要分为三个方面

1. 时间处理：（4个函数）time.time(), time.gmtime(), time.localtime(), time.ctime().
2. 时间格式化：（3个函数）time.mktime(), time.strftime(), time.strptime().
3. 计时：（3个函数）time.sleep(), time.monotonic(), time.perf_counter().

使用 time.time()获取当前时间戳

使用time.gmtime(sec)获取当前时间戳对应的struct_time对象。

使用time.localtime(secs)获取当前时间戳对应的struct_time对象与time.gmtime的区别，是UTC时间已转为北京时间

下标	属性	值
0	tm_year	年份、整数
1	tm_mon	月份[1,12]
2	tm_mday	日期[1,31]
3	tm_hour	小时[0.23]
4	tm_min	分钟[0.59]
5	tm_sec	秒[0,61]
6	tm_wday	星期[0,6](0为星期一)
7	tm_yday	该年第几天[1,366]
8	tm_isdst	是否夏令时,0否,1是,-1未知

>>> import time
>>> lctime=time.localtime()
>>> lctime
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=17, tm_min=15, tm_sec=47, tm_wday=2, tm_yday=68, tm_isdst=0)

time库使用time.mktime(), time.strftime(), time.strptime().进行时间格式化

使用time.mktime(t)将struct_time对象t转换为时间戳，注意t代表当地时间

%Y	年份	0001~9999 例如：1900
%m	月份	01~12 例如10
%B	月名	January~December 例如April
%b	月名缩写	Jan~Dec 例如Apr
%d	日期	01~31例如25
%A	星期	Monday~Sunday例如Wednesday
%a	星期缩写	Mon~Sun例如Wed
%H	小时(24小时)	00~23例如12
%I	小时(12小时)	01~12例如7
%p	上午下午	AM，PM例如PM
%M	分钟	00~59例如26
%S	秒	00~59例如26

>>> import time
>>> time.mktime(time.localtime())
1646817451.0
>>> time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
'2022-03-09 17:25:12'

strptime()与strftime()方法完全相反，用于提取字符串中的时间来生成struct_time()对象，可以很灵活的作为time模块输入接口。

>>> time.strptime('2022-03-09 17:25:12','%Y-%m-%d %H:%M:%S')
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=9, tm_hour=17, tm_min=25, tm_sec=12, tm_wday=2, tm_yday=68, tm_isdst=-1)

第三方库的获取和安装

pip安装：

最常用且最高效的python第三方库安装方式，pip是python官方提供并维护的在线第三方库安装工具，对于python版本环境，可以采用pip3命令代替pip命令专为python3.x版本安装第三方库。

需要联网

安装语法：

pip install 库名

pip工具的使用

除了进行第三方库安装之外，pip工具能对第三方库进行基本的维护、执行pip-h将列出pip常用的子命令

pip支持安装(install)、下载(downloaad)、卸载（uninstall）、列表（list）、查看（show）、查找（search）等一系列安装和维护子命令

pip的uninstall子命令可以卸载一个已经安装的第三方库

语法格式：
pip uninstall 模块名称

pip 的 list子命令可以列出当前系统中已经安装的第三方库

自定义安装

自定义安装按照第三方库提供的步骤和方式安装。第三方库都有主页用于维护库的代码和文档。科学计算用的numpy的官方主页史诗：http：//numpy.org

文件安装：

由于python某些第三方库仅提供源代码，通过pip下载文件后 无法再 windows系统编译安装，会导致第三方库安装失败，在Windows平台下所无法安装到第三方库的问题大多属于这类

---

PyInstaller库

它能够在windows、Linux、MacOS等操作系统下将Python源文件打包、变成直接库运行的可执行文件 。

通过对源文件打包，python程序可以在没有安装python的环境中运行，也可以作为 一个独立的文件方便传递和管理。PyInstaller需要在命令行下用pip工具安装。

pip install PyIsnstaller

pip指令可以将PyInstaller库自动安装到python解释器目录，与pip或pip3命令路径相同。可以直接在命令行调用。

针对不同操作系统打包生成的可执行文件都不相同

库与程序打包

打包：

语法结构：

PyInstall 源文件名

执行完毕后，源文件所在目录将生成dist和build两个文件夹。其中，build目录是PyInstall储存临时文件的目录，可以安全删除，最终的打包程序在dist内部与源文件同中的目录中。目录中其他文件是可执行文件的动态链接库。

可以通过-F参数对python源文件生成一个独立的可执行文件

pyinstall-F a.py

执行后在dist目录中除了a.exe，没有任何依赖库、执行它即可运行程序。

使用PyInstall库需要注意以下问题：

文件路径不能出现空格和英文句号(.)

源文件必须是UTF-8编码，暂时不支持其他编码类型。

参数	功能
-h,--help	查看帮助
--clean	清理打包过程中的临时文件
-D,--onedir	默认值，生成dist目录
-F,--onefile	在disst文件夹中只能生成独立的打包文件
-i<图标文件名.ico>	指定打包程序使用的图标icon文件

---

jieba库概述

由于中文文本的单词不是通过空格或者标点符号分割，中文及类似语言存在一个重要的“分词”问题。

jieba是python中一个重要的第三方中文分词函数库，能够讲一段中文文本分割成中文词语的序列。jieba库需要通过pip指令安装

pip install jieba

jieba库分词原理是利用一个中文词库，将待分词的内容与分词词库进行比对，通过图结构和动态规划方法找到最大概率的词组。除了分词，jieba还提供增加自定义中文单词的功能

jieba库支持三种分词模式：

1. 精确模式，将句子最精确的切开，适合文本分析；
2. 全模式，把句子中所有可以成词的语句都扫描出来，但不能解决歧义，
3. 搜索引擎模式，在精确模式基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词

对中文分词来说jieba只需要一行代码。

jieba库与中文分词

可以辅助自定义分词词典

函数	描述
jieba.lcut(s)	精确模式，返回一个列表类型
jieba.lcut(s,cut_all=True)	全模式，返回一个列表类型
jieba.lcut_for_search(s)	搜索引擎模式，返回一个列表类型
jieba.add_word(w)	向分词字典中增加新词w

jieba.lcut(s)是最常用的 中文分词函数，用于精确模式，即将字符串分割成等量的中文词组，返回结果是列表类型。

jieba.lcut(s,cut_all=True)用于全模式，即将字符串的所有分词可能均列出来，返回结果是列表类型，冗余性最大

相比精确模式，全模式会找到所有分词可能，比如计算机被分词为3个可能词语“计算”，“计算机”，“算机”

jieba.lcut_for_search(s)返回搜索引擎模式，该模式首先执行精确模式，然后再对其中长词进一步切分获得最终结果。存在一定冗余

精确模式因为不产生冗余，最为常用

jieba.add_word()函数，用来想jieba词库增加新的单词。

---

wordcloud库

概述

数据展示的方式多种多样，传统的统计图尽管很科学。但略显古板。尤其对于文本来说更加直观、带有一定艺术感的展示效果需要很大，对于这类需求，词云特有的展示方式深得人心

词云以词语为基本单元，根据其在文本中出现的牝鹿设计不同大小以形成视觉上的不同效果，形成“关键云层”或“关键词渲染”，从而使用读者只要“一警”即可领略本文的主旨。这种方式已经成为本文展示的样板

wordcloud库与可视化词云

wordcloud默认会议空格或标点分隔符对目标文本进行分词处理，对于中文文本，分词处理需要由用户来完成。一般步骤是先将文本分词处理，然后空格拼接，在调用wordcloud库函数，处理中文时还需要指定中文字体。例如，选择了微软雅黑（msyh.ttc）作为显示效果，需要将该字体文件与代码存放同一目录下或在字体文件名前加上完整路径。

参数	功能
font_path	指定字体文件的完整路径，默认None
width	生成图片宽度，默认400像素
height	生成图片高度，默认200像素
mask	词云形状，默认None，即方形图
min_font__size	词云中最小的字体字号，默认4号
font_step	字号步进间隔，默认1
max_font_size	词云中最大的字体符号，默认None，根据高度自我调节
max_words	词云图中最大词数，默认200
stopwords	被排除词列表，排除词不在词云中显示
background_color	图片背景色,默认黑色