参考书籍：《全国计算机等级考试二级教程——Python语言程序设计》（2019年版）
时间：2020年1月3日——2020年3月3日
总字数：47291

第1章 程序设计基本方法

1. Python是一种解释类型的编程语言；
2. Python语言通过缩进来体现语句之间的逻辑关系；
3. Python解释器在语法上不支持自然语言编写方式；
4. IPO模式（Input，Process，Output）
   输入（Input） ：文件输入、网络输入、控制台输入、交互界面输入、随机数据输入、内部参数输入等
   输出（Output） ：控制台输出、图形输出、文件输出、网络输出、操作系统内部变量输出等
   处理（Process）：计算问题的处理方法统称“算法”。
5. i in range(start, stop, step) 是一个范围，它是左闭右开区间，第3个参数代表步长，可以不设置，默认为1；i的取值就是：大于等于第一个参数，小于第二个参数

     >>> list(range(5))[0, 1, 2, 3, 4>>> list(range(1, 6))[1, 2, 3, 4, 5]>>> list(range(1, 6, 2))[1, 3, 5]

6.IDEL的几个快捷
Ctrl+N：在IDEL交互界面下，启动IDEL编辑
Ctrl+Q：退出IDEL Shell或IDEL编辑器
Alt+3 ：在IDEL编辑器内，注释选定区域文本
Alt+4 ：在IDEL编辑器内，撤销注释选定区域文本
Alt+Q ：在IDEL编辑器内，将Python代码进行格式化布局
F5 ：在IDEL编辑器内，执行Python程序

7.print的一些作用

>>> "这是一个字符串"
'这是一个字符串'>>> print("这是一个字符串")
这是一个字符串>>> "{}->{}".format("a", "1")
'a->1'>>> print("{}->{}".format("a", "1"))
a->1

end="," 的作用：以逗号为分隔符进行输出

>>> for i in range(5):print(i)
0
1
2
3
4>>> for i in range(5):print(i, end=",")
0,1,2,3,4,

.join(ls) 的作用：以逗号连接字符

>>> ls = ["a" , "b","c", "d", "e"]
>>> print(ls)
['a', 'b', 'c', 'd', 'e']>>> print(",".join(ls))
a,b,c,d,

第2章 Python语言基本语法元素

1、Python程序的续行符由反斜杠（\） 符号表达，且续行符后面不能存在空格，必须直接换行。

print("{}是{}的首都".format(\"北京",\"中国"\))# 等价于print("{}是{}的首都".format("北京" , "中国"))

2、Python采样大小写字母、数字、下划线和汉字等字符及其组合进行命名，但名字的首字符不能是数字，标识符中间不能出现空格，长度没有限制。

3、Python 3.x版本共有35个保留字，且大小写敏感。

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

其中，黄色标注的22个保留字是Python二级考试范围涉及的

4、字符串是字符的序列，在Python语言中采用一对双引号" " 或者一对 单引号’ ’ 括起来的一个或多个字符来表示。

# 对单个字符串的索引实例
>>> "对酒当歌，人生几何？"[1]
'酒'
>>> "对酒当歌，人生几何？"[-1]
'？'
>>> "对酒当歌，人生几何？"[3]
'歌'
>>> "对酒当歌，人生几何？"[-3]
'几'

采用 [N : M ]格式获取字符串的子串，称为切片。注意：[N : M ]格式获取字符串是从N到M（但不包括M）之间的子串。

# 混合使用正向递增序号和反向递减符号
>>> "譬如朝露，去日苦多。"[2:4]
'朝露'
>>> "譬如朝露，去日苦多。"[5:-2]
'去日苦'
>>> "譬如朝露，去日苦多。"[4:2]
''
>>> "譬如朝露，去日苦多。"[2:2]
''
>>> "譬如朝露，去日苦多。"[:4]
'譬如朝露'
>>> "譬如朝露，去日苦多。"[5:]
'去日苦多。'
>>> print("譬如朝露，去日苦多。"[5:])   # 输出文本字符形式
去日苦多。

5、input()函数：无论用户输入的是字符或是数字，统一按照字符串类型输出。

>>> a = input("请输入：")
请输入：123.456
>>> a
'123.456'
>>> a = input("请输入：")
请输入：a + b + c + d
>>> a
'a + b + c + d'
>>> a = input("请输入：")
请输入：[1, 2, 3, "a", "b", "c"]
>>> a
'[1, 2, 3, "a", "b", "c"]'

6、eval()函数：去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容。

>>> a = eval("1.2")
>>> a
1.2
>>> a = eval("1.2 + 3.4")
>>> a
4.6

>>> value = eval(input("请输入："))
请输入：1024256
>>> print(value * 2)
2048512

等价于：

>>> s = input("请输入：")
请输入：1024.256
>>> value = eval(s)
>>> print(value * 2)
2048.512

7、print()函数：用于输出运算结果，由三种不同用法。
第一种：输出字符串或单个变量

>>> print("世界和平")
世界和平
>>> print(10.01)
10.01
>>> print([1, 2, 3, 4])
[1, 2, 3, 4]
>>> print(["a", "b", "c", "d"])
['a', 'b', 'c', 'd']

第二种：输出一个或多个变量

>>> value = 123.456
>>> print(value, value, value)
123.456 123.456 123.456>>> print("Python语言", "最", "受欢迎")
Python语言 最 受欢迎

第三种：混合输出字符串与变量值

>>> a, b = 123.456, 1024
>>> print("数字{}和数字{}的乘积是{}".format(a, b, a * b))
数字123.456和数字1024的乘积是126418.944

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

>>> a = 24
>>> print(a, end = '.')
24.
>>> print(a, end = '%')
24%

若将上述代码在文件中执行，则

a = 24
print(a, end = '.')
print(a, end = '%')================= RESTART: C:\Users\Yue Xinxin\Desktop\demo.py =================
24.24%

8、len()函数：获取字符串的长度

>>> len("譬如朝露，去日苦多。")
10
>>> len("Hello World")
11

9、实例解析——倒背如流
输入：To be or not to be, that’s a question. ——莎士比亚
输出：亚比士莎—— .noitseuq a s’taht ,eb ot ton ro eb oT

采用正向递增序号：

s = input("请输入一段文本：")i = len(s) - 1while i >= 0:print(s[i], end = "")i = i - 1

采用反向递减序号：

s = input("请输入一段文本：")i = - 1while i >= -1 * len(s):print(s[i], end = "")i = i - 1

采用字符串的高级切片方法：
s[ : :-1]相当于s[-1 : -len(s)-1 : -1]，
字符串倒序输出，-1表示步进长度,当其小于0时,缺省的初值和终值为-1和-len(s)-1

s = input("请输入一段文本：")print(s[: : -1])

第3章 基本数据类型

1、Python提供3种数据类型：整数类型、浮点类型和复数类型。

2、整数类型有4种进制表示，十进制、二进制（0b或0B）、八进制（0o或0O）和十六进制（0x或0X）。进制之间的运算结果默认以十进制方式显示。

3、浮点数有2种表示方法：十进制形式的一般表示和科学计数法表示。

4、整数的运算精度比浮点数高。这是由于浮点数运算存在“不确定尾数”。

>>> pow(1010, 32)
1374940678531097054162291350571104044956417832049380936096496320100000000000000000000000000000000
>>> pow(1010.0, 32)
1.3749406785310972e+96

>>> 0.1 + 0.2
0.30000000000000004

5、round(x, d)：四舍五入函数，其中x是被四舍五入的数，d是保留的小数位数。

6、复数类型：其实部和虚部都是浮点类型，虚数部分通过后缀“”“J”或者“”“j”表示。注意：虚部为1时，1不能省略，即1j表示。用z.real和z.imag分别获得复数的实部和虚部。

>>> (1.23e4 + 5.67e4j).real
12300.0
>>> (1.23e4 + 5.67e4j).imag
56700.0
>>> 1.23e4 + 5.67e4j.imag   # 现获得 5.67e4j的虚部，再与1.23e4进行求和计算。
69000.0

7、数值运算操作符
x//y：x与y的整数商，即：不大于x与y之商的最大整数。
x%y：x与y之商的余数，也称为模运算。主要是用于具有周期规律的场景。例如：一周7天，day代表日期，则day%7可以表示星期几，0表示周日，1表示周一。本质上，整数模运算n%m能够将整数n映射到[0, m-1]。
x**y：x的y次幂，即x^y
8、二元运算操作符用op表示，与赋值符号（=）相连，形成增强赋值操作符。
9、数值运算函数
divmod(x, y)：(x//y, x%y)，输出为二元组形式（也称为元组类型）

>>> divmod(100, 9)
(11, 1)
>>> a, b = divmod(100, 9)
>>> a
11
>>> b
1

pow(x, y) 或 pow(x, y, z)：x ** y 或 (x ** y)%z，幂运算。

>>> pow(10, 2)
100
>>> pow(0x1010, 0b1010)
1382073245479425468920150911010996224
>>> pow(55, 1999999, 10000)    # 计算55的1999999次方的后四位
4375
>>> pow(55, 1999999)%10000  # 计算55的1999999次方的后四位，速度慢。
4375

round(x) 或 round(x, d)：对整数或浮点数进行四舍五入。奇进偶不进。对于x.5，当x为偶数时，x.5不进位，当x为奇数时，x.5进位。

>>> round(0.5)
0
>>> round(1.5)
2
>>> round(0.50001)
1

10、字符串的表示

字符串以Unicode编码存储

>>> print('这是"单行字符串"')
这是"单行字符串"
>>> print("这是'单行字符串'")
这是'单行字符串'
>>> print("""这是'多行字符串'的第一行
这是'多行字符串'的第二行
""")
这是'多行字符串'的第一行
这是'多行字符串'的第二行>>> print('''这是"多行字符串"的第一行
这是"多行字符串"的第二行
''')
这是"多行字符串"的第一行
这是"多行字符串"的第二行

反斜杠字符（\）：表示续行。
\n：表示换行；
\：表示反斜杠；
'：表示单引号；
"：表示双引号；
\t：表示制表符（Teb）

a = eval(input())
if (a > 10 and a<100) or \(a < -10 and a < -100):print("BINGO")

>>> print("这里\n有个换行")
这里
有个换行
>>> print("这里\\有个反斜杠")
这里\有个反斜杠
>>> print("既需要'单引号'又需要\"双引号\"")
既需要'单引号'又需要"双引号"
>>> print("这里\t有个制表符")
这里  有个制表符

11、format()的使用

字符串的格式化：在字符串中整合变量，用于解决字符串和变量同时输出时的格式安排问题。

>>> "{}曰：学而时习之，不亦说乎".format("孔子")
'孔子曰：学而时习之，不亦说乎'

>>> "{}曰：学而时习之，不亦{}".format("孔子", "说乎")
'孔子曰：学而时习之，不亦说乎'

>>> "{1}曰：学而时习之，不亦{0}".format("说乎", "孔子")
'孔子曰：学而时习之，不亦说乎'

>>> "《论语》是{}弟子所著。{}曰：学而时习之，不亦说乎。".format("孔子")
Traceback (most recent call last):File "<pyshell#6>", line 1, in <module>"《论语》是{}弟子所著。{}曰：学而时习之，不亦说乎。".format("孔子")
IndexError: tuple index out of range

>>> "《论语》是{0}弟子所著。{0}曰：学而时习之，不亦说乎。".format("孔子")
'《论语》是孔子弟子所著。孔子曰：学而时习之，不亦说乎。'

>>> "{1}曰：{{学而时习之，不亦{0}}}".format("说乎", "孔子")
'孔子曰：{学而时习之，不亦说乎}'

12、format()槽的格式控制

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

>>> s = "等级考试"
>>> "{:25}".format(s)                     # 默认左对齐
'等级考试                     '
>>> "{:1}".format(s)               # 指定宽度为1，变量s宽度比指定宽度长，则以变量的宽度为准
'等级考试'
>>> "{:^25}".format(s)                  # 居中对齐
'          等级考试           '
>>> "{:>25}".format(s)                 # 右对齐
'                     等级考试'
>>> "{:*^25}".format(s)                # 默认左对齐且填充*
'**********等级考试***********'

格式控制标记可以用变量来表示，即用槽来指定所对应的的控制标记及数量。

>>> s = "等级考试"
>>> y = "-"
>>> "{0:{1}^25}".format(s, y)                # 指定代表填充字符的变量y
'----------等级考试-----------'>>> "{0:{1}^{2}}".format(s, y, 25)          # 指定代表填充字符和宽度的变量，y和25
'----------等级考试-----------'>>> z = "^"
>>> "{0:{1}{3}{2}}".format(s, y, 25, z)    # 指定代表填充字符、对齐和宽度的变量，y、z和25
'----------等级考试-----------'

>>> "{:-^25}".format(1234567890)
'-------1234567890--------'>>> "{:-^25,}".format(1234567890)
'------1,234,567,890------'

>>> "{:.2f}".format(12345.67890)
'12345.68'>>> "{:>25.2f}".format(12345.67890)
'                 12345.68'>>> "{:.5}".format("全国计算机等级考试")
'全国计算机'
>>> "{:.15}".format("全国计算机等级考试")
'全国计算机等级考试'

>>> "{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%'

13、字符串处理函数

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

>>> len("全国计算机等级考试Python语言科目")
19

>>> str(1010)
'1010'>>> str(0x3f)
'63>>> str(3.1415926)
'3.1415926'

>>> chr(1010)
'ϲ'>>> chr(10000)
'✐'
>>> ord("☆")
9734

>>> hex(1010)
'0x3f2'>>> oct(-255)
'-0o377'

>>> chr(0x025b)
'ɛ'
>>> chr(0x2708)
'✈'
>>> chr(0x00A5)
'¥'
>>> chr(0x266B)
'♫'

14、字符串处理方法

方法	描述
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(iter)	将iter变量的每一个元素后面增加一个str字符串

>>> "Python".lower()
'python'>>> "Python".upper()
'PYTHON'

>>> "Python is an excellent language.".split()
['Python', 'is', 'an', 'excellent', 'language.']>>> "Python is an excellent language.".split('a')
['Python is ', 'n excellent l', 'ngu', 'ge.']>>> "Python is an excellent language.".split('an')
['Python is ', ' excellent l', 'guage.']

>>> "Python is an excellent language.".count('a')
3>>> "Python is an excellent language.".count('an')
2>>> "Python is an excellent language.".count(' ')
4

>>> "Python is an excellent language.".replace('a', '#')
'Python is #n excellent l#ngu#ge.'>>> "Python is an excellent language.".replace('Python', 'C')
'C is an excellent language.'>>> "Python is an excellent language.".replace('excellent', '')
'Python is an  language.'>>> "Python is an excellent language.".replace('a', '')
'Python is n excellent lnguge.'

>>> "Python".center(20, "=")
'=======Python======='>>> "Python".center(2, "=")
'Python'

>>> "    ==Python==    ".strip(' ')    # 加空格
'==Python=='>>> "    ==Python==    ".strip(' =')    # 加空格和等号
'Python'>>> "    ==Python==    ".strip(' =n')
'Pytho'

>>> "".join('PYTHON')
'PYTHON'>>> ",".join('12345')
'1,2,3,4,5'>>> ",".join(['1', '2', '3', '4', '5'])
'1,2,3,4,5'

15、变量类型判断

>>> type(10.10)
<class 'float'>>>> type(1010)
<class 'int'>>>> type('10.10')
<class 'str'>>>> type([1, 0, 1, 0])
<class 'list'>

16、变量类型间转换

>>> int(10.10)
10>>> int(10)
10>>> float(10)
10.0>>> float(123.456)
123.456>>> str(10.01)
'10.01'>>> str(1010+101)
'1111'

17、

第4章 程序的控制结构

1、程序的3种基本控制结构：顺序结构、分支结构和循环结构

2、在分支结构原理的基础上，Python增加了异常处理，使用try-expect保留字。

3、在循环结构原理的基础上，Python提供两个循环控制符break和continue，对循环的执行过程进行控制。
break：结束当前循环
continue：结束当前循环的当次循环过程。

4、二分支结构的一种简洁表达方式。

<表达式1> if <条件> else <表达式2>

# 判断用户输入数字的某个属性s = eval(input("请输入一个整数："))token = "" if s % 3 == 0 and s % 5 ==0 else "不"print("这个数字{}能够同时被3和5整除".format(token))============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个整数：123
这个数字不能够同时被3和5整除============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个整数：150
这个数字能够同时被3和5整除

5、Python语言中，任何非零的数值、非空的数据类型都等价于True，0或空类型等价于False，可以直接用作判断条件。

6、Python语言有两种循环结构：遍历循环（for）和无限循环（while）。
遍历循环：从遍历结构中逐一提取元素，放在循环变量中，对于每一个所提取的元素执行一次语句块。for语句的循环次数是根据遍历结构中的元素个数确定的。

for <循环变量> in <字符串变量>:<语句块>

for c in "Python":print(c)============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
P
y
t
h
o
n

for i in range(5):print(i)============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
0
1
2
3
4

for s in "PY":print("循环执行中："+s)
else:s = "循环正常结束"
print(s)============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
循环执行中：P
循环执行中：Y
循环正常结束

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

while <条件>:<语句块>

n = 0
while n<10:print(n)n = n + 3============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
0
3
6
9

s, idx = "PY", 0
while idx < len(s):print("循环执行中："+s[idx])idx += 1
else:s = "循环正常结束"
print(s)============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
循环执行中：P
循环执行中：Y
循环正常结束

7、循环控制：break和continue
break：用于挑出最内层for或while循环，脱离该循环后程序继续执行循环后续代码。

while True:s = input("请输入一个名字（按Q退出）：")if s == "Q":breakprint("输入的名字是：", s)
print("程序退出")============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个名字（按Q退出）：张三
输入的名字是： 张三
请输入一个名字（按Q退出）：李四
输入的名字是： 李四
请输入一个名字（按Q退出）：Q
程序退出

如果有2层或多层循环，break退出最内层循环

while True:s = input("请输入一个名字（按Q退出）：")if s == "Q":break                         # 退出while循环for c in s:if c == "E":break                         # 退出for循环，但不退出while循环print(c, end="")
print("程序退出")============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个名字（按Q退出）：E
请输入一个名字（按Q退出）：Q
程序退出

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

for s in "PYTHON":if s == "Y":continueprint(s, end="")============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
PTHON

continue语句和break语句的区别：
continue只结束本次循环，不终止整个循环的执行；
break具备结束整个当前循环的能力。

8、程序的异常处理
Python使用try-except进行异常处理。

try:<语句块1>
except:<语句块2>

语句块1是正常执行的内容，当执行这个语句块发生异常时，则执行except后的语句块2.

try:n = eval(input("请输入一个数字："))print("输入数字的3次方值为：",n**3)
except:print("输入错误，请输入一个数字！")============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============10
请输入一个数字：10010
输入数字的3次方值为： 1003003001000============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个数字：Python
输入错误，请输入一个数字！

try:for i in range(5):print(10/i, end = "")
except:print("某种原因，出错了！")============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
某种原因，出错了！

try:for i in range(5):print(10/i, end = "")
except ZeroDivisionError:print("除数为零，产生了除零错误！")
except:print("某种原因，出错了！")============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
除数为零，产生了除零错误！

9、实例——猜数字游戏
编写一个“猜数字游戏”的程序，在1~1000之间随机产生一个数，然后用户循环猜这个数字，对于每个答案只回答“猜大了”或“猜小了”，知道猜准确为止，输出用户的猜测次数。

import random
target = random.randint(1, 1000)
count = 0
while True:guess = eval(input("请输入一个猜测的整数（1至1000）："))count = count + 1if guess > target:print("猜大了")elif guess < target:print("猜小了")else:print("猜对了")break
print("次轮的猜测次数为：", count)============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个猜测的整数（1至1000）：500
猜小了
请输入一个猜测的整数（1至1000）：800
猜小了
请输入一个猜测的整数（1至1000）：900
猜小了
请输入一个猜测的整数（1至1000）：950
猜小了
请输入一个猜测的整数（1至1000）：990
猜大了
请输入一个猜测的整数（1至1000）：980
猜大了
请输入一个猜测的整数（1至1000）：970
猜大了
请输入一个猜测的整数（1至1000）：960
猜大了
请输入一个猜测的整数（1至1000）：955
猜大了
请输入一个猜测的整数（1至1000）：954
猜对了
次轮的猜测次数为： 10

为了增加程序的鲁棒性，增加异常处理机制

import random
target = random.randint(1, 1000)
count = 0
while True:try:guess = eval(input("请输入一个猜测的整数（1至1000）："))except:print("输入有误，请重试，不计入猜测次数！")continuecount = count + 1if guess > target:print("猜大了")elif guess < target:print("猜小了")else:print("猜对了")break
print("次轮的猜测次数为：", count)============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
请输入一个猜测的整数（1至1000）：500
猜小了
请输入一个猜测的整数（1至1000）：python
输入有误，请重试，不计入猜测次数！
请输入一个猜测的整数（1至1000）：600
猜小了
请输入一个猜测的整数（1至1000）：700
猜小了
请输入一个猜测的整数（1至1000）：800
猜大了
请输入一个猜测的整数（1至1000）：750
猜大了
请输入一个猜测的整数（1至1000）：740
猜大了
请输入一个猜测的整数（1至1000）：730
猜小了
请输入一个猜测的整数（1至1000）：735
猜大了
请输入一个猜测的整数（1至1000）：734
猜大了
请输入一个猜测的整数（1至1000）：733
猜大了
请输入一个猜测的整数（1至1000）：732
猜对了
次轮的猜测次数为： 11

第5章 函数和代码复用

1、使用函数的目的：降低编程难度和增加代码复用。

2、函数的定义：

def <函数名>(<参数列表>)：<函数体>return <返回值列表>

# 定义一个队整数n求阶乘的函数
def fact(n):s = 1for i in range(1, n+1):s *=ireturn s

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

3、函数的使用：

<函数名>(<实际赋值参数列表>)

# 定义一个队整数n求阶乘的函数
def fact(n):s = 1for i in range(1, n+1):s *=ireturn s
# 调用整数阶乘的函数
print(fact(100))

函数的使用步骤：
函数定义、函数调用、函数执行、函数返回

4、函数的可选参数传递

def <函数名>(<非可选参数列表>, <可选参数列表> = <默认值>)：<函数体>return <返回值列表>

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

5、参数名称传递
函数调用时，默认采用按照位置顺序的方式传递给函数。采用参数名称传递方式不需要保持参数传递的顺序。

<函数名>(<参数名> = <实际值>)

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

6、函数的返回值
return：结束函数并将程序返回到函数被调用的位置继续进行执行。
单个返回值

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

多个返回值，返回一个元组数据类型。可使用一个或多个变量保存。

>>> 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

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

>>> def manyret(x):try:if x > 0:return x + 1else:return x - 1except:return 0>>> manyret(2)
3
>>> manyret(-1)
-2
>>> manyret(0)
-1
>>> manyret('a')
0

7、变量分为：局部变量和全局变量
局部变量：仅在函数内部，且作用域也在函数内部。
全局变量：作用域跨越多个函数。

>>> n = 2    # n是全局变量
>>> def multiply(x, y = 10):global nreturn x * y * n    #使用全局变量n>>> s = multiply(99, 2)
>>> print(s)
396

>>> n = 2    # n是全局变量
>>> def multiply(x, y = 10):n = x * yreturn n   #此处的n不是全局变量>>> s = multiply(99, 2)
>>> print(s)
198
>>> print(n)
2

8、代码复用：紧耦合和松耦合。

第6章 组合数据类型

1、常用的组合数据类型：集合类型、序列类型和映射类型。

集合类型是一个具体的数据类型名称；
序列类型和映射类型是一类数据类型的总称。
序列类型包括：字符串类型、列表类型和元组类型。
映射类型是序列类型的一种扩展。

2、集合类型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。集合中的元素不可重复，用大括号（{}）表示，没有索引和位置的概念，集合中的元素可以动态增加和删除。

>>> S = {1010, "1010", 78.9}
>>> type(S)
<class 'set'>
>>> len(S)
3
>>> print(S)
{'1010', 1010, 78.9}

>>> T = {"1010", 12.3, 1010}
>>> print(T)
{'1010', 1010, 12.3}
>>> T = {"1010", 12.3, 1010, 1010, 1010}
>>> print(T)
{'1010', 1010, 12.3}

集合类型的4种操作符：交集（&）、并集（|）、差集（-）和补集（^）

>>> S = {1010, "1010", 78.9}
>>> T = {"1010", 12.3, 1010, 1010, 1010}
>>> S & T
{'1010', 1010}
>>> T & S
{'1010', 1010}
>>> S | T
{'1010', 1010, 12.3, 78.9}
>>> T | S
{'1010', 1010, 12.3, 78.9}
>>> S - T
{78.9}
>>> T - S
{12.3}
>>> S ^ T
{12.3, 78.9}
>>> T ^ S
{12.3, 78.9}

集合类型常用的操作函数或方法

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

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

>>> S = set()
>>> type(S)
<class 'set'>
>>> S = set("知之为知之不知为不知")
>>> S
{'之', '知', '为', '不'}
>>> for i in S:print(i, end = "")之知为不

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

3、序列类型是一维元素向量，元素之间存在先后关系，通过序号访问。
序列类型包括：字符串类型、列表类型和元组类型。
序列类型常用的操作符和函数

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

序列类型之一——元组类型
在Python中表示为“tuple”，一般以小括号和逗号进行组织。当函返回多个值时，多个返回值以以元组类型返回，实际上返回一个数据类型。

>>> t = (1, 2, 3)
>>> type(t)
<class 'tuple'>

>>> t = (1, 2, 3)
>>> 1 in t
True
>>> "1" not in t
True
>>> 1 not in t
False
>>> s = (4, 5, 6)
>>> t + s
(1, 2, 3, 4, 5, 6)
>>> t * 2
(1, 2, 3, 1, 2, 3)
>>> 2 * t
(1, 2, 3, 1, 2, 3)
>>> t[1]
2
>>> t[:2]
(1, 2)
>>> t[::2]
(1, 3)
>>> len(t)
3
>>> min(t)
1
>>> max(t)
3
>>> t.index(2)
1
>>> t.count(1)
1

>>> for c in (1, 2, 3):print(c, end = "月")1月2月3月

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

序列类型之二——列表类型
列表是包含0个或多个元组的有序序列。可以进行元素的增加、删除、替换和查找等操作。没有长度限制，元素类型可以不同，不需要预定义长度。用中括号（[]）表示，也可通过list(x)函数将集合或字符串类型转换成列表类型，list()函数生成空列表。

>>> ls = [1010, '1010', [1010, '1010'], 1010]
>>> ls
[1010, '1010', [1010, '1010'], 1010]
>>> list('列表可以有字符串生成')
['列', '表', '可', '以', '有', '字', '符', '串', '生', '成']
>>> list()
[]
>>> type(ls)
<class 'list'>

>>> list("Python")
['P', 'y', 't', 'h', 'o', 'n']
>>> list({'小明', '小红', '小白', '小新'})
['小明', '小新', '小红', '小白']
>>> list({"201801": '小明',"201802": '小红',"201803": '小白'})
['201801', '201802', '201803']

列表属于序列类型，支持序列类型常用的操作符和函数

>>> ls = [1010, '1010', [1010, '1010'], 1010]
>>> 1010 in ls
True
>>> "1010" not in ls
False
>>> lt = [1, 2, 3]
>>> ls + lt
[1010, '1010', [1010, '1010'], 1010, 1, 2, 3]
>>> lt * 2
[1, 2, 3, 1, 2, 3]
>>> len(ls)
4
>>> ls.index(1010)
0
>>> ls.count(1010)
2

列表的索引，不能超过列表的元素范围。

>>> ls = [1010, '1010', [1010, '1010'], 1010]
>>> ls[3]
1010
>>> ls[-2]
[1010, '1010']
>>> ls[5]
Traceback (most recent call last):File "<pyshell#19>", line 1, in <module>ls[5]
IndexError: list index out of range

>>> ls = [1010, '1010', [1010, '1010'], 1010]
>>> for i in ls:print(i*2)2020
10101010
[1010, '1010', 1010, '1010']
2020

列表的切片，<列表或列表变量>[N : M]，一般要求N小于M。N>M时返回空列表。

>>> ls = [1010, '1010', [1010, '1010'], 1010]
>>> ls[1:4]
['1010', [1010, '1010'], 1010]
>>> ls[-1:-3]
[]
>>> ls[-3:-1]
['1010', [1010, '1010']]
>>> ls[0:4:2]
[1010, [1010, '1010']]

>>> ls = [1010, '1010', [1010, '1010'], 1010]
>>> len(ls)
4
>>> lt = ["Python", ['1010', 1010, [1010, 'Python']]]
>>> len(lt)
2

>>> ls = [1010, 10.10, 0x1010]
>>> min(ls)
10.1
>>> lt = ['1010', '10.10', 'Python']
>>> max(lt)
'Python'
>>> ls = ls + lt
>>> print(ls)
[1010, 10.1, 4112, '1010', '10.10', 'Python']
>>> min(ls)
Traceback (most recent call last):File "<pyshell#40>", line 1, in <module>min(ls)
TypeError: unorderable types: str() < float()

>>> list("Python")
['P', 'y', 't', 'h', 'o', 'n']
>>> list({'小明'， '小红', '小白', '小新'})
SyntaxError: invalid character in identifier
>>> list({'小明', '小红', '小白', '小新'})
['小明', '小新', '小红', '小白']
>>> list({"201801": '小明',"201802": '小红',"201803": '小白'})
['201801', '201802', '201803']

列表的操作方法

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

ls.append(x)仅用于在列表最后增加一个元素。

>>> lt = ['1010', '10.10', 'Python']
>>> lt.append(1010)
>>> print(lt)
['1010', '10.10', 'Python', 1010]
>>> lt.append([1010, 0x1010])
>>> print(lt)
['1010', '10.10', 'Python', 1010, [1010, 4112]]

>>> lt = ['1010', '10.10', 'Python']
>>> ls = [1010, [1010, 0x1010]]
>>> ls += lt
>>> print(ls)
[1010, [1010, 4112], '1010', '10.10', 'Python']

ls.insert(i, x)

>>> lt = ['1010', '10.10', 'Python']
>>> lt.insert(1, 1010)
>>> print(lt)
['1010', 1010, '10.10', 'Python']

ls.clear()

>>> lt = ['1010', '10.10', 'Python']
>>> lt.clear()
>>> print(lt)
[]

ls.pop(i)

>>> lt = ['1010', '10.10', 'Python']
>>> print(lt.pop(1))
10.10
>>> print(lt)
['1010', 'Python']

ls.remove(x)删除列表中第一次出现的元素x

>>> lt = ['1010', '10.10', 'Python', '10.10']
>>> lt.remove('10.10')
>>> print(lt)
['1010', 'Python', '10.10']

del <列表变量>[<索引序号>]
或
del <列表变量>[<索引起始> : <索引结束>]
或
del <列表变量>[<索引起始> : <索引结束> : <步长>]

>>> lt = ['1010', '10.10', 'Python']
>>> del lt[1]
>>> print(lt)
['1010', 'Python']
>>> lt = ['1010', '10.10', 'Python']
>>> del lt[1 : ]
>>> print(lt)
['1010']
>>> lt = ['1010', '10.10', 'Python', 1010, 1111]
>>> del lt[1:4:2]
>>> print(lt)
['1010', 'Python', 1111]

ls.reverse()

>>> lt = ["1010", "10.10", "Python"]
>>> lt.reverse()
>>> print(lt)
['Python', '10.10', '1010']

>>> lt = ["1010", "10.10", "Python"]
>>> print(lt.reverse())
None

ls.copy()

>>> lt = ["1010", "10.10", "Python"]
>>> ls = lt.copy()
>>> lt.clear()
>>> print(ls)
['1010', '10.10', 'Python']

注意：对于整数或字符串，可以通过等号实现赋值。但对于列表类型，使用等号无法实现真正的赋值，其中，ls = lt并不是拷贝lt中的元素给ls，而是新关联一个引用，即ls和lt所指向的是同一套内容。

>>> lt = ["1010", "10.10", "Python"]
>>> ls = lt
>>> lt.clear()
>>> print(ls)
[]

使用索引配合等号（=）可以对列表元素进行修改。

>>> lt = ["1010", "10.10", "Python"]
>>> lt[1] = 1010
>>> print(lt)
['1010', 1010, 'Python']

使用切片配合等号（=）可以对列表片段进行修改，修改内容可以不等长。当使用一个列表改变另一个列表值时，Python不要求两个列表长度一样，但遵循“多增少减”的原则。

>>> lt = ["1010", "10.10", "Python"]
>>> lt[1:2] = [1010, 10.10, 0x1010]
>>> print(lt)
['1010', 1010, 10.1, 4112, 'Python']
>>> lt[1:4] = [1010]
>>> print(lt)
['1010', 1010, 'Python']

4、字典类型
使用大括号（{}）建立，每一个元素是一个键值对，使用方法如下：

{<键1>:<值1>, <键2>:<值2>, ... ,<键n>:<值n>}

可以简单地把字典看成元素是键值对的集合。
字典的索引

<值> = <字典变量>[<键>]

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> print(d["201802"])
小红
>>> d["201802"] = '新小红'
>>> print(d)
{'201802': '新小红', '201803': '小白', '201801': '小明'}

>>> t = {}
>>> t['201804'] = '小新'
>>> print(t)
{'201804': '小新'}

字典的操作函数

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

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> len(d)
3
>>> min(d)
'201801'
>>> max(d)
'201803'
>>> d = dict()
>>> print(d)
{}

字典的操作方法

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

d.keys()

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> d.keys()
dict_keys(['201802', '201803', '201801'])
>>> type(d.keys())
<class 'dict_keys'>
>>> list(d.keys())
['201802', '201803', '201801']

d.values()

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> d.values()
dict_values(['小红', '小白', '小明'])
>>> type(d.values())
<class 'dict_values'>
>>> list(d.values())
['小红', '小白', '小明']

d.items()

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> d.items()
dict_items([('201802', '小红'), ('201803', '小白'), ('201801', '小明')])
>>> type(d.items())
<class 'dict_items'>
>>> list(d.items())
[('201802', '小红'), ('201803', '小白'), ('201801', '小明')]

d.get(key, default)

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> d.get('201802')
'小红'
>>> d.get('201804')
>>> d.get('201804', '不存在')
'不存在'

d.pop(key, default)

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> d.pop('201802')
'小红'
>>> print(d)
{'201803': '小白', '201801': '小明'}
>>> d.pop('201804', '不存在')
'不存在'

d.popitem()

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> print(d.popitem())
('201802', '小红')
>>> d
{'201803': '小白', '201801': '小明'}

d.clear

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> d.clear()
>>> print(d)
{}

删除字典中某一元素。

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> del d['201801']
>>> print(d)
{'201802': '小红', '201803': '小白'}

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

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> '201801' in d
True
>>> '201804' in d
False

>>> d = {"201801": '小明',"201802": '小红',"201803": '小白'}
>>> for k in d:print("字典的键和值分别是：{}和{}".format(k, d.get(k)))字典的键和值分别是：201802和小红
字典的键和值分别是：201803和小白
字典的键和值分别是：201801和小明

第7章 文件和数据格式化

1、文件的类型：文本文件和二进制文件。
文本文件：一般由单一特定编码的字符组成，如UTF-8编码，内容容易统一展示和阅读。由于文本文件存在编码，所以，它可以看成存储在磁盘上的长字符串，如一个txt格式的文本文件
二进制文件：直接由比特0和比特1组成，没有统一的字符编码，文件内部数据的组织格式与文件用途有关。二进制是信息按照非字符但有特定格式形成的文件，如png图片文件和avi视频文件。可当做字节流，不能看作字符串。

2、文件的打开和关闭

<变量名> = open(<文件路径及文件名>, <打开模式>)

文件的打开模式

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

以文本方式只读打开一个文件，读入后不能对文件进行修改。

<变量名> = open(<文件名>, 'r')     或    <变量名> = open(<文件名>)

以文本方式可读写地打开一个文件，可以读入并修改文件。

<变量名> = open(<文件名>, 'r+')

以文本方式打开一个空文件，准备写入一批内容，并保存为新文件。

<变量名> = open(<文件名>, 'w')

以文本方式打开一个空文件或已有文件，追加形式写入一批内容，更新原文件

<变量名> = open(<文件名>, 'a+')

以二进制方式只读打开一个文件，读入后不能对文件进行修改。

<变量名> = open(<文件名>, 'rb')

文件使用结束后要用close()方法关闭，释放文件的使用授权，语法形式如下:

<变量名>.close(0

注意：由于“\”是字符串中的转义符，所以表示路径时，使用“\”或“/”代替“\”。

>>> PATH = "D:\\"
>>> f = open(PATH + "bar.txt", "rt")
>>> print(f.readline())
新年都为有芳华，二月初惊见草芽。>>> f.close()
>>> print(f.readline())
Traceback (most recent call last):File "<pyshell#13>", line 1, in <module>print(f.readline())
ValueError: I/O operation on closed file.

3、文件的读写
文件的读取方法

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

f.read(size = -1)

>>> f = open("D:/bar.txt", "r")
>>> s = f.read()
>>> print(s)
新年都为有芳华，二月初惊见草芽。
白雪却嫌春色晚，故穿庭树作飞花。

>>> f = open("D:/bar.txt", "r")
>>> s = f.read(3)
>>> print(s)
新年都

f.readline(size = -1)

>>> f = open("D:/bar.txt", "r")
>>> s = f.readline()
>>> print(s)
新年都为有芳华，二月初惊见草芽。

>>> f = open("D:/bar.txt", "r")
>>> s = f.readlines()
>>> print(s)
['新年都为有芳华，二月初惊见草芽。\n', '白雪却嫌春色晚，故穿庭树作飞花。']

结合读取指针，下述代码ls返回值为空，因为之前f.read()已经读取了文件全部内容，读取指针在文件末尾，再次调用f.readlines()已经无法从当前读取指针处读入内容，因此返回结果为空。

>>> f = open("D:/bar.txt", "r")
>>> s = f.read()
>>> print(s)
新年都为有芳华，二月初惊见草芽。
白雪却嫌春色晚，故穿庭树作飞花。
>>> ls = f.readlines()
>>> print(ls)
[]
>>> f.close()

f.seek(offset)

>>> f = open("D:/bar.txt", "r")
>>> s = f.read()
>>> print(s)
新年都为有芳华，二月初惊见草芽。
白雪却嫌春色晚，故穿庭树作飞花。
>>> f.seek(0)
0
>>> ls = f.readlines()
>>> print(ls)
['新年都为有芳华，二月初惊见草芽。\n', '白雪却嫌春色晚，故穿庭树作飞花。']
>>> f.close()

使用遍历循环逐行遍历文件

f = open("D:/bar.txt", "r")
for line in f:print(line)
f.close()============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
新年都为有芳华，二月初惊见草芽。白雪却嫌春色晚，故穿庭树作飞花。

文件的写入

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

>>> f = open("D:/c.txt", "w")
>>> f.write('新年都为有芳华，\n')
9
>>> f.write('二月初惊见草芽。\n')
9
>>> f.write('白雪却嫌春色晚，\n')
9
>>> f.write('故穿庭树作飞花。\n')
9
>>> f.close()

>>> ls = ['新年都为有芳华，\n', '二月初惊见草芽。\n', '白雪却嫌春色晚，\n', '故穿庭树作飞花。\n']
>>> f = open("D:/c.txt", "w")
>>> f.writelines(ls)
>>> f.close()

4、数据组织分为：一维数据、二维数据和高维数据。

5、一维数据
一维数据的表示：采用列表形式表示

>>> ls = ['北京', '上海', '天津', '重庆']
>>> print(ls)
['北京', '上海', '天津', '重庆']

一维数据的存储：
采用空格分割元素

北京  上海  天津  重庆

采用逗号分割元素，叫做CSV格式（Comma-Separated Values，即逗号分割值）

北京,上海,天津,重庆

采用换行分割元素

北京
上海
天津
重庆

其他特殊符号分割

北京;上海;天津;重庆

列表对象输出为CSV格式。

>>> ls = ['北京', '上海', '天津', '重庆']
>>> f = open("D:/city.csv", "w")
>>> f.write(",".join(ls) + "\n")
12
>>> f.close()

一维数据的处理：

>>> f = open("D:/city.csv", "r")
>>> lt = f.read().strip('\n').split(',')
>>> f.close()
>>> print(lt)
['北京', '上海', '天津', '重庆']

注意：从CSV文件中获取内容时，最后一个元素后面包含一个换行符（"\n"）。这是多余的，需要使用strip()去掉，进一步使用split()以逗号进行分割。

6、二维数据
二维数据的表示：采用二维列表来表示。一般采用相同的数据类型存储数据。
二维数据输出为CSV格式文件

# ls表示二维列表，此处省略
f = open("D:/cpi.csv", "w")
for row in ls:f.write(",".join(row) + "\n")
f.close()

从CSV文件读入二维数据

f = open("D:/cpi.csv", "w")
ls = []
for line in f:ls.append(line.strip('\n').split(","))
f.close()
print(ls)

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

for row in ls:for item in row:<对第row行第item列元素进行处理>

对二维数据进行格式化输出，打印成表格形状，代码如下：

for row in ls:line = ""for item in row:line += "{:10}\t".format(item)print(line)

第8章 Python计算生态

1、计算思维的本质：抽象（abstraction）和自动化（automation）

2、基本程序设计方法学：自顶向下设计和自底向上执行。

3、Python解释器提供import保留字辅助开展单元测试，语法格式如下：

import <源文件名称>

4、Python第三方程序：库（Python标准库和Python第三方库）、模块和程序包。

5、基本的Python内置函数

函数名称	函数说明
abs(x)	x的绝对值。如果x是复数，返回复数的模
all(x)	组合类型变量x中所有元素都为真时返回True，否则返回False；若x为空，返回True
any(x)	组合类型变量x中任一元素为真时返回True，否则返回False；若x为空，返回False
bin(x)	将整数x转化为等值的二进制字符串，如bin(1010)的结果是’0b1111110010’
bool(x)	将x转换为Boolean类型，即True或False。如bool(’’)的结果是False
chr(i)	返回Unicode为i的字符。如chr(9996)的结果为’✌’
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作为Python表达式的值。如eval(‘1+99’)的结果是100
exec(s)	计算字符串s作为Python语句的值。如exec(‘a=1+999’)运行后，变量a的值为1000
float(x)	将x转换成浮点数。如float(1010)的结果是1010.0
hex(x)	将整数转换为16进制字符串。如hex(1010)的结果是’0x3f2’
input(s)	获取用户输入，其中s是字符串，作为提示信息。s可选
int(x)	将x转换成整数。如int(9.9)的结果是9
len(x)	计算变量x的长度。如len(range(10))的结果是10
list(x)	创建或将变量x转换成一个列表。如list({10, 9, 8})的结果是[10, 9, 8]
max(a1, a2, …)	返回参数的最大值，如max(1, 2, 3, 4, 5)的结果是5
min(a1, a2, …)	返回参数的最小值，如min(1, 2, 3, 4, 5)的结果是1
oct(x)	将整数x转换成等值的八进制字符串形式。如oct(1010)的结果是’0o1762’
open(fname, m)	打开文件，包括文本方式和二进制方式。其中，m可省略，默认是以文本可读形式打开
ord(char)	返回一个字符的Unicode编码值。如ord(‘字’)的结果是23383
pow(x, y)	返回x的y次幂。如pow(2, pow(2, 2))的结果是16
print(x)	打印变量或字符串x。print()的end参数用来表示输出的结尾字符
range(a, b, s)	从a到b（不含）以s为步长产生一个序列。如list(range(1, 10, 3))的结果是[1, 4, 7]
reversed(d)	返回组合类型d的逆序迭代形式。如for i in reversed([1, 2, 3])将逆序遍历列表
round(n)	四舍五入方式计算n。如round(10.6)的结果是11
set(x)	将组合数据类型x转换成集合类型。如set([1, 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’>

6、

第9章 Python标准库概览

1、turtle库概述
turtle图形绘制概念诞生于1969年，成功应用于LOGO编程语言。
刚开始绘制时，小海龟位于画布正中央，坐标为(0, 0)，前进方向为水平右方。

绘图坐标体系：

turtle库的引用：
第一种：

import turtle
turtle.circle(200)

第二种：

from turtle import *
circle(200)

或者

from turtle import circle
circle(200)

第三种

import turtle as t
t.circle(200)

turtle库包含100多个功能函数主要包括窗体函数、画笔状态函数和画笔运动函数。

窗体函数

turtle.setup(width, height, startx, starty)
作用：设置主窗体的大小和位置。
参数：
width：窗口宽度。如果值是整数，表示的是像素值；如果值是小数，表示窗口宽度与屏幕的比例；
height：窗口高度。如果值是整数，表示的是像素值；如果值是小数，表示窗口宽度与屏幕的比例；
startx：窗口左侧与屏幕左侧的像素距离。如果值是None，窗口位于屏幕水平中央；
starty：窗口顶部与屏幕顶部的像素距离。如果值是None，窗口位于屏幕水平中央；

画笔状态函数

函数	描述
pendown()	放下画笔
penup()	提起画笔，与pendown()配对使用
pensize(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.penup() 或 turtle.pu() 或turtle.up()
作用：提起画笔，之后，移动画笔不绘制形状。
参数：无

turtle.pendown() 或 turtle.pd() 或turtle.down()
作用：放下画笔，之后，移动画笔绘制形状。
参数：无

turtle.pensize(width) 或 turtle.width()
作用：设置画笔宽度，当无参数输入时返回当前画笔宽度
参数：
width：设置的画笔线条宽度，如果为None或者为空，函数则返回当前画笔宽度。

turtle.pencolor(colorstring) 或 turtle.pencolor((r, g, b))
作用：设置画笔颜色，当无参数输入时返回当前画笔颜色。
参数：
colorstring：表示颜色的字符串，如：“purple”, “red”, "blue"等。
(r, g, b)：颜色对应的RGB的0~1数值，如：1, 0.65, 0。

turtle.color(colorstring1, colorstring2) 或 turtle.pencolor((r1, g1, b1), (r2, g2, b2))
作用：设置画笔和背景颜色，当无参数输入时返回当前画笔和背景颜色。
参数：
colorstring：表示颜色的字符串，如：“purple”, “red”, "blue"等。
(r, g, b)：颜色对应的RGB的0~1数值，如：1, 0.65, 0。

turtle.begin_fill()
作用：设置填充区域色彩。开始绘制拟填充背景图形前调用。
参数：无

turtle.end_fill()
作用：turtle.begin_fill()的配对函数。结束绘制拟填充背景图形后调用。
参数：无

import turtle as t
t.color("red", "blue")
t.begin_fill()
t.circle(100)
t.end_fill()

turtle.filling()
作用：返回当前图形背景颜色的填充状态，即如果当前代码在begin_fill()和end_fill()之间，则返回True，否则返回False。
参数：无

turtle.clear()
作用：清空当前海龟对象绘制的图形，但不改变其位置和角度。
参数：无

turtle.reset()
作用：清空当前绘图窗口，海龟对象绘图位置和角度归为原点。
参数：无

turtle.screensize(width, height, bgcolor)
作用：设置当前画布窗口的宽度为width，高度为heigth，背景颜色为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个元素构成的元组。该参数可选，省略时已默认参数显示。

import turtle as t
t.write("Write Function", font = ('Arial', 40, 'normal'))

画笔运动函数

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

turtle.forward(distance) 或 turtle.fd(distance)
作用：小海龟向当前行进方向前进distance距离。
参数：
distance：行进距离的像素值。当值为负值时，表示向相反方向前进。

turtle.backward(distance) 或 turtle.bk(distance)
作用：向小海龟当前行进的反方向运动distance距离，画笔方向不变。
参数：
distance：行进距离的像素值。当值为负值时，表示向前进方向运动。

turtle.rigth(angle)
作用：改变画笔行进方向为当前方向右侧angle度。angle是角度的相对值。
参数：
angle：角度的整数值。

turtle.left(angle)
作用：改变画笔行进方向为当前方向左侧angle度。angle是角度的相对值。
参数：
angle：角度的整数值。

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

turtle.setx(x)
作用：修改画笔的横坐标到x，纵坐标不变。
参数：
x：画布中横坐标的一个值。

turtle.sety(y)
作用：修改画笔的横坐标到x，纵坐标不变。
参数：
y：画布中纵坐标的一个值。

turtle.setheading(to_angle) 或 turtle.seth(to_angle)
作用：设置小海龟当前行进方向为to_angle，该角度是绝对方向角度值。
参数：
to_angle：角度的整数值。

turtle.home()
作用：移动画笔到坐标系原点，画笔方向为初始方向。
参数：无

turtle.circle(radius, extent = None, steps=None)
作用：根据半径radius绘制extent角度的弧形。
参数：
radius：弧形半径。当值为正数时，半径在小海龟左侧，当值为负值时，半径在小海龟右侧。
extent：绘制弧形的角度。当不给该参数或参数为None时，绘制整个圆形。
steps：做半径为radius的圆的内切正多边形，多边形边数为steps。

turtle.dot(size, color)
作用：绘制一个带有背景色color、直径为size的圆点。
参数：
size：圆点的直径，像素值。
color：颜色字符串或RGB的0~1值，表示背景颜色。

turtle.undo()
作用：撤销绘图的最后一次动作。
参数：无

turtle.speed()
作用：设置画笔的绘制速度，参数为0-10整数，0表示没有绘制动作，1-10逐步增加绘制速度，超过10则等同于参数为零。
参数：
s：速度的设定值，0~10之间的整数。

2、random库概述

random库的常用函数

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

random.random()是最基本的函数，所有其他随机函数都是基于这个函数扩展而来。与其他编程语言相似，Python中随机数的生成基于随机数“种子”，每个种子作为输入，利用算法生成一系列随机数，构成为随机序列。random库使用random.seed(a)对后续产生的随机数设置种子a。

random.seed(s)
作用：为随机序列确定种子，其中参数为种子。
参数：
s：随机种子，一个整数或浮点数。若不设置种子，则使用随机数生成函数前，将默认以当前系统的运行时间为种子产生随机序列。

random.random()
作用：生成一个[0.0, 1.0)之间的随机小数，注意不包括1.0
参数：无

>>> from random import *
>>> seed(10)
>>> random()
0.5714025946899135
>>> random()
0.4288890546751146
>>> seed(10)       # 再次设置相同的种子，则后续产生的随机数相同。
>>> random()
0.5714025946899135
>>> random()
0.4288890546751146

random.randint(a, b)
作用：生成一个[a, b]之间的随机整数。注意，随机数可能等于b。
参数：
a, b：一个整数

>>> from random import *
>>> randint(1, 10)
10
>>> randint(1, 1000)
16
>>> randint(-1000, 1000)
-578

random.getrandbits(k)
作用：生成k比特长度的随机整数，其中k是二进制数的长度。
参数：
k：一个整数。

>>> from random import *
>>> getrandbits(100)
1068890625628921251469938371847
>>> len(bin(1068890625628921251469938371847))
102
>>> bin(1068890625628921251469938371847)
'0b1101011111011100010110011010001110101101000000110101110100100101100101110110011010111010110100000111'

random.randrange(start, stop[ , step])
作用：生成一个[start, stop]之间以step为步数的随机整数
参数：
start：一个整数，表示开始整数。
stop：一个整数，表示结束整数。
step：一个整数，表示步长。

>>> from random import *
>>> randrange(10, 1000, 5)
365
>>> randrange(10, 1000, 5)
845
>>> randrange(10, 1000, 5)
215

random.uniform(a, b)
作用：生成一个[a, b]之间的随机小数。注意，随机数可能等于b。
参数：
a, b：一个整数或浮点数。

>>> from random import *
>>> uniform(10, 100)
13.096321648808136
>>> uniform(1.1, 99.8)
49.471446933233565
>>> uniform(1.1, 99.8)
8.610018527319063

random.choice(seq)
作用：从序列类型（列表、元组或字符串）中随机返回一个元素。
参数：
seq：一个序列类型变量。

>>> from random import *
>>> choice("Python123")
'n'
>>> choice([1, 2, 3, 4, 5])
1
>>> choice(("Python", "123"))
'123'

random.shuffle(seq)
作用：将序列类型中元素随机排列，返回打乱后的序列。序列类型包括列表。由于排序后对原有变量进行重写，所以该函数不能作用于不可变序列，即主要用于列表类型。
参数：
seq：一个序列类型变量。

>>> from random import *
>>> ls = [1, 2, 3, 4, 5]
>>> shuffle(ls)
>>> ls
[1, 4, 5, 3, 2]

random.sample(pop, k)
作用：从pop表示的组合数据类型中随机选取k个元素，以列表类型返回。注意pop中所含的元素要不少于k个。
参数：
pop：一个组合数据类型，如集合、列表、元组、字符串等。
k：一个整数。

>>> from random import *
>>> sample({1, 2, 3, 4, 5, 6}, 3)
[3, 6, 4]
>>> sample({1, 2, 3, 4, 5, 6}, 3)
[2, 3, 5]
>>> sample({1, 2, 3, 4, 5, 6}, 3)
[2, 4, 6]

3、time库概述

time库的3个方面功能：时间处理、时间格式化和计时。
时间处理主要包括4个函数：time.time()、time.gmtime()、time.localtime()、time.ctime()。

time.time()：获取当前时间戳。

>>> import time
>>> time.time()
1583049536.7231467

time.gmtime(secs)：获取当前时间戳对应的struct_time对象。

>>> import time
>>> now = time.time()
>>> time.gmtime(now)
time.struct_time(tm_year=2020, tm_mon=3, tm_mday=1, tm_hour=8, tm_min=1, tm_sec=22, tm_wday=6, tm_yday=61, tm_isdst=0)

time.localtime(secs)：获取当前时间戳对应的本地时间的struct_time对象。

>>> time.localtime(now)
time.struct_time(tm_year=2020, tm_mon=3, tm_mday=1, tm_hour=16, tm_min=1, tm_sec=22, tm_wday=6, tm_yday=61, tm_isdst=0)

time.ctime(secs)：获取当前时间戳对应的易读字符串表示。

>>> time.ctime(now)
'Sun Mar  1 16:01:22 2020'

时间格式化主要包括3个函数：time.mktime()、time.strftime()、time.strptime()。

time.mktime(t)将struct_time对象t转换为时间戳，注意t代表当地时间。
struct_time对象的元素构成

下标	属性	值
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
>>> now = time.time()
>>> t = time.localtime(now)
>>> time.mktime(t)
1583050656.0
>>> time.ctime(time.mktime(t))
'Sun Mar  1 16:17:36 2020'

time.strftime()是最有效的时间格式化方法。

>>> lctime = time.localtime()
>>> lctime
time.struct_time(tm_year=2020, tm_mon=3, tm_mday=1, tm_hour=16, tm_min=20, tm_sec=17, tm_wday=6, tm_yday=61, tm_isdst=0)
>>> time.strftime("%Y-%m-%d %H:%M:%S", lctime)
'2020-03-01 16:20:17'

strftime()方法的格式化控制符

格式化字符串	日期/时间	值范围和实例
%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	小时（24h制）	00~23，例如12
%I	小时（12h值）	01~12，例如7
%p	上/下午	AM, PM，例如PM
%M	分钟	00~59，例如26
%S	秒	00~59，例如26

strptime()与strftime()方法相反，用于提取字符串中的时间来生成struct_time对象。

>>> timeString = '2020-03-01 16:20:17'
>>> time.strptime(timeString, "%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2020, tm_mon=3, tm_mday=1, tm_hour=16, tm_min=20, tm_sec=17, tm_wday=6, tm_yday=61, tm_isdst=-1)

计时主要包括3个函数：time.sleep()、time.monotonic()、time.perf_counter()。

# 以1000万次循环为主体，模拟实际程序的核心模块，用time.sleep()模拟实际程序的其他模块。
import time
def coreLoop():limit = 10 ** 8while(limit > 0):limit -= 1def otherLoop1():time.sleep(0.2)def otherLoop2():time.sleep(0.4)def main():startTime = time.localtime()print("程序开始时间：", time.strftime("%Y-%m-%d %H:%M:%S", startTime))startPerfCounter = time.perf_counter()otherLoop1()otherLoop1PerCounter = time.perf_counter()otherLoop1Per = otherLoop1PerCounter - startPerfCountercoreLoop()coreLoopPerCounter = time.perf_counter()coreLoopPer = coreLoopPerCounter - otherLoop1PerCounterotherLoop2()otherLoop2PerCounter = time.perf_counter()otherLoop2Per = otherLoop2PerCounter - coreLoopPerCounterendPerCounter = time.perf_counter()totalPer = endPerCounter - startPerfCounterendTime = time.localtime()print("模块1运行时间是：{}秒".format(otherLoop1Per))print("核心模块运行时间是：{}秒".format(coreLoopPer))print("模块2运行时间是：{}秒".format(otherLoop2Per))print("程序运行总时间是：{}秒".format(totalPer))print("程序结束时间：", time.strftime("%Y-%m-%d %H:%M:%S", endTime))
main()============= RESTART: C:\Users\jiajia\Desktop\Python\example.py =============
程序开始时间： 2020-03-01 16:56:53
模块1运行时间是：0.1994189528754115秒
核心模块运行时间是：11.298680143697707秒
模块2运行时间是：0.3997935915682902秒
程序运行总时间是：11.897895151249186秒
程序结束时间： 2020-03-01 16:57:05

第10章 Python第三方库概览

1、Python第三方库的安装方法：pip工具安装、自定义安装和文件安装。
pip工具安装

：\>pip install pygame

自定义安装
按照第三方库提供的步骤和方式安装。

文件安装

：\>pip install C:\Python\wordcloud-1.6.0-cp35-cp35m-win_amd64.whl

2、pip工具使用

Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。C:\Users\jiajia>pip -hUsage:pip <command> [options]Commands:install                     Install packages.download                    Download packages.uninstall                   Uninstall packages.freeze                      Output installed packages in requirements format.list                        List installed packages.show                        Show information about installed packages.check                       Verify installed packages have compatible dependen
cies.config                      Manage local and global configuration.search                      Search PyPI for packages.wheel                       Build wheels from your requirements.hash                        Compute hashes of package archives.completion                  A helper command used for command completion.debug                       Show information useful for debugging.help                        Show help for commands.General Options:-h, --help                  Show help.--isolated                  Run pip in an isolated mode, ignoringenvironment variables and user configuration.-v, --verbose               Give more output. Option is additive, and can beused up to 3 times.-V, --version               Show version and exit.-q, --quiet                 Give less output. Option is additive, and can beused up to 3 times (corresponding to WARNING,ERROR, and CRITICAL logging levels).--log <path>                Path to a verbose appending log.--proxy <proxy>             Specify a proxy in the form[user:passwd@]proxy.server:port.--retries <retries>         Maximum number of retries each connection shouldattempt (default 5 times).--timeout <sec>             Set the socket timeout (default 15 seconds).--exists-action <action>    Default action when a path already exists:(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.--trusted-host <hostname>   Mark this host or host:port pair as trusted,even though it does not have valid or any HTTPS.--cert <path>               Path to alternate CA bundle.--client-cert <path>        Path to SSL client certificate, a single filecontaining the private key and the certificatein PEM format.--cache-dir <dir>           Store the cache data in <dir>.--no-cache-dir              Disable the cache.--disable-pip-version-checkDon't periodically check PyPI to determinewhether a new version of pip is available fordownload. Implied with --no-index.--no-color                  Suppress colored output--no-python-version-warningSilence deprecation warnings for upcomingunsupported Pythons.

3、PyInstaller库概述
PyInstaller是一个能够在Window、Linux和MacOS等操作系统下将Python源文件（即，.py文件）打包，变成直接可运行的可执行文件。
使用方法：

:\>pyinstaller -F <Python源程序文件名>

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

:\>pyinstaller -F SnowDraw.py

执行后在dist目录中只生成SnowDraw.exe文件，没有任何依赖库。

PyInstaller命令的常用参数

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

:\>pyinstaller -i snowflake.ico -F SnowDraw.py

4、jieba库概述

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

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

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

jieba库常用的分词函数

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

jieba.lcut(s)

>>> import jieba
>>> ls = jieba.lcut("全国计算机等级考试Python科目")
Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\jiajia\AppData\Local\Temp\jieba.cache
Loading model cost 1.904 seconds.
Prefix dict has been built successfully.
>>> print(ls)
['全国', '计算机', '等级', '考试', 'Python', '科目']

jieba.lcut(s, cut_all = True)

>>> import jieba
>>> ls = jieba.lcut("全国计算机等级考试Python科目", cut_all = True)
>>> print(ls)
['全国', '国计', '计算', '计算机', '算机', '等级', '考试', 'Python', '科目']

jieba.lcut_for_search(s)

>>> import jieba
>>> ls = jieba.lcut_for_search("全国计算机等级考试Python科目")
>>> print(ls)
['全国', '计算', '算机', '计算机', '等级', '考试', 'Python', '科目']

jieba.add_word(w)

>>> import jieba
>>> jieba.add_word("Python科目")
>>> ls = jieba.lcut("全国计算机等级考试Python科目")
>>> print(ls)
['全国', '计算机', '等级', '考试', 'Python科目']

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

例如：

>>> from wordcloud import WordCloud
>>> txt = 'I like python. I am learning python'
>>> wordcloud = WordCloud().generate(txt)
>>> wordcloud.to_file('testcloud.png')
<wordcloud.wordcloud.WordCloud object at 0x0000000003829860>

执行效果如下：

>>> import jieba
>>> from wordcloud import WordCloud
>>> txt = "程序设计语言是计算机能够理解和识别用户操作意图的一种交互体系，它按照特定规则组织、计算机指令，使得计算机能够自动进行各种运算处理。"
>>> words = jieba.lcut(txt)
>>> newtxt = ' '.join(words)
>>> wordcloud = WordCloud(font_path="msyhl.ttc").generate(newtxt)
>>> wordcloud.to_file('词云中文例子图.png')
<wordcloud.wordcloud.WordCloud object at 0x000000000F2377B8>

运行结果如下：

WordCloud对象创建的常用参数

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

WordCloud类的常用方法

方法	功能
generate(text)	由text文本生成词云
to_file(filename)	将词云保存为名为filename的文件

wordcloud也可以生成任何形状的词云。

第11章 Python第三方库纵览

网络爬虫：requests、scrapy
requests：一个简洁且简单的处理HTML页面的程序。
scrapy：是Python开发的一个快速的、高层次的Web获取框架。

数据分析：numpy、scipy、pandas
numpy：是Python的一种开源数值计算扩展第三方库，用于处理数据类型相同的多维数组（ndarray），简称“数组”。
scipy：是一款方便、易用、专为科学与工程设计的Python包，它是在numpy库的基础上增加了众多的数学、科学及工程计算中常用的库函数。它包括统计、优化、整合、线性代数、傅里叶变换、信号分析、图像处理、常微分方程求解等众多模块。
pandas：是基于numpy扩展的一个重要第三方库，它是为解决数据分析任务而创建的。pandas提供了一批标准的数据模型和大量快速便捷处理数据的函数和方法，提供了高效地操作大型数据集所需的工具。

机器学习：scikit-learn、TensorFlow、Theano
scikit-learn：是一个简洁且高效的数据挖掘和分析工具。基本功能主要包括6个部分：分类、回归、聚类、数据降维、模型选择和数据预处理。
TensorFlow：Tensor（张量）指N维数组，Flow（流）指基于数据流图的计算。描述张量从流图的一端流动到另一端的计算过程。应用于语音识别、图像识别、机器翻译、自主跟踪等。
Theano：为执行深度学习中大规模神经网络算法的运算而设计，擅长处理多维数组。

数据可视化：matplotlib、TVTK、mayavi
matplotlib：是提供数据绘图功能的第三方库，主要进行二维图表数据展示，广泛用于科学计算的数据可视化。
TVTK：是在标准的VTK库之上用Traits库进行封装的Python第三方库。视觉工具函数库（Visualization toolkit，VTK）是一个开源、跨平台、支持平行处理的图形应用函数库，是专业可编程的三维可视化工具。
mayavi：基于VTK开发，完全用Python编写，提供了一个更为方便实用的可视化软件，可以简洁地嵌入到用户编写的Python程序中，或直接使用其面向脚本的API快速绘制三维可视化图形。

文本处理：pdfminer、openpyxl、python-docx、beautifulsoup4
pdfminer：是一个可以从PDF文档中提取各类信息的第三方库。与其他PDF相关的工具不同，它能够完全获取并分析PDF的文本数据。能够获取PDF中文本的准确位置、字体、行数等信息，能够将PDF转换成HTML及文本格式。
openpyxl：是一个处理Microsoft Excel文档的Python第三方库，支持读写Excel的xls、xlsx、xlsm、xltx、xltm等格式文件，并进一步处理Excel文件中的工作表、表单和数据单元。
python-docx：是一个处理Microsoft Word文档的Python第三方库，支持读取、查询及修改doc、docx等格式文件，并能够对Word常见样式进行编程设置，包括字符样式、段落样式、表格样式、页面样式等，进一步可以使用这个库实现添加和修改文本、图形、样式和文档等功能。
beautifulsoup4：也称Beautiful Soup库或bs4库，用于解析和处理HTML和XML。

游戏开发：Pygame、Panda3D、cocos2d
Pygame：面向游戏开发入门的Python第三方库，处理制作游戏外，还用于制作多媒体应用程序。
Panda3D：是一个开源、跨平台的3D渲染和游戏开发库。
cocos2d：是一个构建2D游戏和图形界面交互式应用的框架。

Web开发：Django、Pyramid、Flask
Django：Python生态中最流行的开源Web应用框架。
Pyramid：是一个通用、开源的Python Web应用程序开发框架。
Flask：是轻量级Web应用框架，相比于Django、Pyramid，它被称为微框架。

用户图形界面：PyQt5、wxPython、PyGTK
PyQt5：是当前最好用的GUI第三方库。
wxPython：一套优秀的GUI图形库。
PyGTK：提供各式的可视元素和功能，能够轻松创建具有图形用户界面的程序。

更过第三方库：PIL、SymPy、NLTK、WeRoBot、MyQR
PIL：是Python在图像处理方面的重要第三方库，支持图像存储、处理和显示，它能够处理几乎所有格式的图片，可以完成对图像的缩放、剪裁、叠加以及向图像添加线条、图像和文字等操作。处理图像首选PIL。
SymPy：是一个支持符号计算的Python第三方库。是一个全功能的计算机代数系统。支持符号计算、高精度计算、模式匹配、绘图、解方程、微积分、组合数学、离散数学、几何学、概率与统计、物理学等领域的计算与应用。
NLTK：是一个非常重要的自然语言处理Python第三方库，支持多种语言，尤其是对中文支持良好。
WeRoBot：是一个微信公众号开发框架，也称微信机器人框架。
MyQR：是一个能够产生基本二维码、艺术二维码和动态效果二维码的Python第三方库。

Python——理论学习笔记相关推荐

1. 字节跳动大佬的Python自学笔记.pdf

   1. 字节跳动大佬的Python自学笔记 这是我的一个朋友自学资料包,通过这个资料包自学拿到了字节跳动的Offer, 下面是他之前入门学习Python时候的学习资料,非常全面,从Python基础.到w ...

2. [python教程入门学习]python学习笔记（CMD执行文件并传入参数）

   本文章向大家介绍python学习笔记(CMD执行文件并传入参数),主要包括python学习笔记(CMD执行文件并传入参数)使用实例.应用技巧.基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋 ...

3. python学习笔记之编写readConfig读写配置文件

   python学习笔记之编写readConfig读写配置文件_weixin_34055910的博客-CSDN博客

4. Python学习笔记（十一）

   Python学习笔记(十一): 生成器,迭代器回顾 模块 作业-计算器 1. 生成器,迭代器回顾 1. 列表生成式:[x for x in range(10)] 2. 生成器 (generator o ...

5. Python学习笔记一简介及安装配置

   Python学习笔记一 参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e54 ...

6. python学习笔记目录

   人生苦短,我学python学习笔记目录: week1 python入门week2 python基础week3 python进阶week4 python模块week5 python高阶week6 数据结 ...

7. Python学习笔记（二）：标准流与重定向

   Python学习笔记(二):标准流与重定向 - SamWei - 博客园 Python学习笔记(二):标准流与重定向 Posted on 2012-02-19 22:36 SamWei 阅读(176) ...

8. python 学习笔记 12 -- 写一个脚本获取城市天气信息

   近期在玩树莓派,前面写过一篇在树莓派上使用1602液晶显示屏,那么可以显示后最重要的就是显示什么的问题了. 最easy想到的就是显示时间啊,CPU利用率啊.IP地址之类的.那么我认为呢,假设可以显示当 ...

9. Python机器学习笔记：sklearn库的学习

   自2007年发布以来,scikit-learn已经成为Python重要的机器学习库了,scikit-learn简称sklearn,支持包括分类,回归,降维和聚类四大机器学习算法.还包括了特征提取,数据 ...

10. python输入数字翻译成星期几-Python练习笔记——计算输入日期为改年的第几天、星期几...

    # 输入年月日,如:1995年12月10日,计算是该年的第几天? # 同时计算出当天是星期几? print("请依据提示依次输入您想查询的年 月 日") # 第一段代码块(年月日输 ...

最新文章

1. java txt中文乱码,JAVA读取TXT文件 可解决中文乱码问题
2. 支撑微博千亿调用的轻量级RPC框架：Motan
3. 如何提高在家办公的效率？
4. python六十四: 迭代器协议
5. node.js发送邮件
6. C语言学习之通过指针变量调用它所指向的函数
7. 周华健，歌声伴我成长（三）
8. greenplum客户端工具_GreenPlum数据加载工具gpload | 信春哥，系统稳，闭眼上线不回滚！...
9. resin 系统日志_resin日志
10. protel99se原理图设计，怎样显示隐藏的“PART TYPE”？
11. ps快速抠头发-庞姿姿
12. cad图层置顶的lisp_cad中的底图老置顶，如何让它永久置底？
13. pythonhistogram教程_Plot Histogram in Python
14. 沉睡者 - 微信内测一个手机可注册2微信号
15. QQ升到9个太阳需要58年左右时间!
16. 全息投影+电子干扰+脑波识别
17. 关于新闻类应用快速开发框架的思考
18. 《十一月的肖邦》——麦芽糖
19. windows mobile ?
20. 美国防部将发布联合全域指挥控制 (JADC2) 战略实施计划

热门文章

1. 80题题目+AC代码汇总 ~ 南阳 NYOJ
2. 火狐插件 打开html 死机,火狐flash插件崩溃(Firefox火狐Flash插件卡死问题完美解决方法)...
3. 矢量绘图软件源码定制开发，类似visio绘图，大量复合图元模板，可编程动态控制图元
4. 亲爱的，别把上帝缩小了 ---- 读书笔记1
5. jw播放器 html5,JW播放器HTML5专用模式
6. 如何利用 HBuilderX 制作图文混排的网页
7. python 城市地图_Python查询一个城市的谷歌地图的经度和纬度
8. 1、Android APP开发基础
9. 电脑激活Office时出现异常，激活界面白屏或提示无法与服务器
10. NAT模式和桥接模式的区别详解