学习 | 备战计算机二级 Python

Day 1

1 变量命名要求与类型

1.1 Python3.5及以上版本的保留字总数是(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

1.2 Python 的变量命名需要注意的是

1. 由数字、字母、下划线组成
2. 不能以数字开头、变量名不能包含特殊字符，如@、#、$
3. 不能使用Python内置关键字
4. 严格区分大小写

2 Python 的数据类型

type(var)     # 可以使用函数来获取变量的数据类型

# 整数：<class'int'>
# 浮点数：<classfloat'>      !只有十进制表现形式
# 复数：<class'complex'>
# 字符串：<class'str'>
# 布尔类型：<class'bool'>

2.1 数值型 - 整数型

整数型可以是：-100、13 这样的数，当然也可也是进制数，以下进制表示也是整数型。

2.1.1 进制转换 —— 按权展开式

二进制 -> 十进制

$1010=1 \times 2^3+0 \times 2^2+1 \times 2^1+0 \times 2^0=8+0+2+0=10$

八进制 -> 十进制

$167=1 \times 8^2+6 \times 8^1+7 \times 8^0=64+48+7=119$

十六进制 -> 十进制

$24 B=2 \times 16^2+4 \times 16^1+11 \times 16^0=512+64+11=587$

2.3 数值型 - 浮点类型

普通浮点数： 1.23 3.14

科学计数法浮点数： 1.01e4 -1.2E5 （计算方法见下）

$1.01e4=1.01 \times 10^4=10100.0$

2.4 数值型 - 复数类型 （实际上用的不多）

复数 $z = a+bj$ ，其中 $a$ 是实数部分，简称实部， $b$ 是虚数部分，简称虚部（高中学过啦）。虚数部分通过后缀“”或“j”来表示。

$j=\sqrt{-1}$，j为虚数单位

注意：当b为1时，1不能省略，即 $1j$。

例：$11.3 + 4j$ 、$-5 + 2j$ 、 $10+5j$

对于复数 z ，可以使用 z.real 和 z.imag 分别获取它的实部和虚部。 以下为例子

a = 12 + 5j
print(a.real)    # 获取变量 a 的实数部分
print(a.imag)    # 获取变量 a 的虚数部分
# !返回的均是浮点类型

x = 10
y = -1 + 2j
print(x + y)    # 结果输出 (9+2j)

2.5 数据类型 - 字符串

字符串并不陌生，和 PHP 、JAVA 一样使用"或者'括起来。以下为例子

但 Python 可以用三个上面的符号进行直接换行，下面的strC为例子

strA = "Hello World"
strB = 'hello word'
strC = """各位同人们：
    大家好！
    我是XXX，接下来...
"""

注意：使用直接换行时不要将第一个"""后又回车，不然就变成了多行注释了！

2.6 数据类型 - 布尔类型

通常用于逻辑判断 True & False 无需多言！

3 运算符 & 连接符

算术运算符共九种，下表为九种运算符的描述与实例。

3.1 算术运算符

注意：使用整型 + 字符串你得线转换，见下方例子。

prize = 9.15
string = "衬衫的价格是："
end = '＄'

print(string + end + str(prize))
# 输出为：衬衫的价格为：＄9.15


x = "hello!"
print(x * 2)
# 输出为：hello!hello!

3.2 赋值运算符、增强赋值操作符

特别的玩法：

a = 3
b = 5
a, b =b, a    # 将 a 的值和 b 互换


s1 = s2 = s3 = 123    # 同时赋值多个变量
print(s1, s2, s3)

3.3 关系运算符

以下假设变量a为10，变量b为20：

3.4 逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

3.5位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100
b = 0000 1101
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0

c = a & b;        # 12 = 0000 1100
print "1 - c 的值为：", c

c = a | b;        # 61 = 0011 1101 
print "2 - c 的值为：", c

c = a ^ b;        # 49 = 0011 0001
print "3 - c 的值为：", c

c = ~a;           # -61 = 1100 0011
print "4 - c 的值为：", c

c = a << 2;       # 240 = 1111 0000
print "5 - c 的值为：", c

c = a >> 2;       # 15 = 0000 1111
print "6 - c 的值为：", c

# 1 - c 的值为： 12
# 2 - c 的值为： 61
# 3 - c 的值为： 49
# 4 - c 的值为： -61
# 5 - c 的值为： 240
# 6 - c 的值为： 15

注意：他不同于与 PHP 的“并且”运算 Python 需要使用 and

4 常用的函数

4.1 input() 函数

input 函数可以接收键盘输入的内容，数据类型为 String 字符串。以下为例子。

#输入三角形的三边长
a,b,c = (input("请输入三角形三边的长：").split())
a= int(a)
b= int(b)
c= int(c)

#计算三角形的半周长p
p=(a+b+c)/2

#计算三角形的面积s
s=(p*(p-a)*(p-b)*(p-c))**0.5

#输出三角形的面积
print("三角形面积为：",format(s,'.2f'))

输出结果为：

请输入三角形三边的长：3 4 5
三角形面积为： 6.00

4.2 if-else 条件语句(二分支结构)

if 判断条件：
    执行语句……
else：
    执行语句……

由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

### if 语句多个条件

num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print 'hello'
# 输出结果: hello

num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine

num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine

注意：当 if 有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

4.3 循环语句的使用

循环语句主要与两个，一个是 for 遍历循环，一个是 while 无限循环！

4.3.1 while 循环

while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：

while 判断条件：
    执行语句

prize = 100
while prize > 60:
    print(str(prize) + "还是太贵了！再便宜一点~")
    prize -= 10
print("行！就" + str(prize) + "吧！")bye!"

注意：当然还有一种特别的情况。以下为例子

sum = 0
i = 1
while i < 100:
    sum = sum + i
    i = i + 1
else:
    # 当 while 达到条件循环结束以后还会执行一次 else 相当于还有一次没有达到条件
print(sum)

4.3.1.1 循环控制

在循环中我们可以使用 continue 来结束当前本次循环并且 continue 后面的代码不会继续执行，直接执行下一次循环！

break 来跳过循环，退出循环！以下为例子

# 输出 1 - 100 的所有偶数
i = 0
while i < 100:
    i += 1
    if i % 2 == 0:
        print(i)

# 输出 1 - 100 的所有奇数
i = 0
while i < 100:
    i += 1
    if i % 2 == 0:
        continue
    else:
        print(i)

# 输出 1 - 100 的前 3 个偶数
count = 0
i = 0
while i < 100:
    if count == 3:
        break

    i += 1
    if i % 2 == 0:
        count += 1
        print(i)

4.3.2 for() 遍历循环

可迭代对象：如字符串、列表、元组、字典等可以用来遍历循环的数据。

for<循环变量> in <可迭代对象>:
    <循环体>

s1 = "abcdefg"
for i in s1:
    print(i)
# 他就会一行一行输出 abcdefg

4.4 print() 打印函数

print() 函数没有上面多介绍的，值的注意的是打印后还可以跟数值。例如以下例子

print(123,end = "元")    # end 的默认值为 \n
# 输出为：123元，并且不会换行了！

5 程序的异常处理

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

注意：这里说的异常不是语法错误！

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

捕捉异常可以使用 try/except 语句。

try/except 语句用来检测try语句块中的错误，从而让except 语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在 try 里捕获它。以下为例子。

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

# 它打开一个文件，在该文件中的内容写入内容，且并未发生异常
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

Day 2

6 函数的基础

对内隐藏细节，对外暴露接口。 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。

6.1 定义一个函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。

• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

  def functionname( parameters ):
     "函数_文档字符串"
     function_suite
     return [expression]

特别的：函数不可以为空，但是我们可以用 pass 语句对清占位置。以下为例子

def sample(n_samples):
    pass    # 但在Python3.x的时候pass可以写或不写

6.2 函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

def printme( str ):
   "打印任何传入的字符串"
   print str
   return

# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

下面我将用一个例子来进行学习：

形式参数：简称“形参”，函数定义（声明）时使用的参数。

实际参数：简称“实参”，函数被调用时实际传入的参数。

# 两位数加法运算
def plusNumber(a,b):    # a 和 b 是形参
    return(a + b)

returnValue = plusNumber(5,6)    # 5 和 6 是实参
print(returnValue)

当然，使用元组也可也实现以下功能：

def fun(a,b)
    return b,a
n,m = fun(3,4)
print(n)    # 输出为4

6.3 函数参数与返回值

一个函数可以是 无参数、无返回值；无参数，有返回值；

# 输出1-100之间的和
# 无参数、无返回值
def fun1():
    sum = 0
    i=1
    whilei<=100:
        sum +=i
        i+=1
    print(sum)

# 计算1-100之间的和，并返回
# 无参数，有返回值
def fun2():
    sum = 0 
    i = 1
    while i<=100:
        sum +=i
        i+=1
    return sum

# 实现传入一个成绩，判断该成绩是否及格，并输出“及格”或“不及格
def fun3(s):
if s >= 60:
    print("及格”)
else:
    print("不及格”)

fun3(60)

# 实现传入一个成绩，判断该成绩是否及格，及格返回 True ，否则返回 False
def fun4(s):
    if s >= 60
        return True
    else:
        return False

一个函数也可也设定他的传参默认值(可选参数)，当没选中使保证程序可用！

[Warnning!] 可选参数必须放到 非可选参数后面，不然会报错

def fun(a, b = 5):
    return a + b
print(fun(1))    #结果输出为 6


def fun(a, b = 5):
    return a + b
print(fun(1,1))    #结果输出为 2

6.4 函数变量的作用域

在一个 Python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误

n = 2    # n 为全局变量

def fun(a,b):
    global n    # 声明在本作用域中使用全局变量 n
    n = a * b
    print(n)


fun(5,6)    # 输出为 30

7 常见的字符串操作

7.1 字符串操作符号

常见的字符串操作符又 3 种：

使用 in 就可以实现判断某个字符是否在字符串里面出现过。以下为例子

s1 = "How are you?"
print("are" in s1)    # 输出为 True

7.2 字符串的索引与切片

索引 用来表示字符串中字符的所在位置，基于位置，可以快速找到其对应的字符，如果一个字符串中有n个字符，那么索引l的取值范围是 0~n~1

<字符串或字符串变量>[索引]

s = "How are you?"
print(s[0])    #结果输出为 H （空格也算）

切片 可以获取字符串指定索引区间的字符！

值得注意的是：开始索引和结束索引是左闭右开区间。例子如下。

<字符串或字符串变量>[开始索引：结束索引：步长(默认1)]


s = "How are you?"
print(s[1:6])    # 结果输出为 ow ar（不包含第6个字符e）
print(s[1:])    # 从第一个位置到最后一个字符
print(s[:8])    # 从第 0 个字符取到第八个字符，不包括第八个字符
print(s[:])    # 不用多说了！举一反三 ~


print(s[0:11:2])    # 加入步长，没格2个字符取一个(不包含第二字符)
# 输出为 Hwaeyu

print(s[::-1])    # 步长为 -1 可以逆向排列
# 输出为?uoy era woH

7.3 字符串中常用函数

7.4 字符串常用处理方法

这个 str 类的方法

7.5 字符串格式化处理

<模板字符串>.format(<参数列表>)

模板字符串是一个由字符串和槽组成的字符串，用来控制字符串和变量的显示效果。槽 用 {} 表示，与 format() 中的参数列表对应。以下为例子。

s1 = """欢迎您！{}：
新的一天也要元气满满哦 ~ """
print(s1.format("admin"))


s1 = """欢迎您！{0}：
新的一天也要{1}哦 ~ """
print(s1.format("往来无白丁","不折不挠"))
# 输出：欢迎您！往来无白丁：\n新的一天也要不折不挠哦 ~ 

以下用法例子来自菜鸟教程：

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

还可以对其格式化处理(处理的时候就不可以赋值了)：

# b：整数二进制形式
# c：输出整数对应的Unicode字符
# d：整数十进制形式
# o：整数八进制形式
# X：整数大写十六进制形式
# x：整数小写十六进制形式
# f：四舍五入保留x位小数

s = "二级考试"
print("{:*^25}".format(s))
# 输出为：**********二级考试***********

s = "全国计算机二级考试"
print("{:.5}".format(s))
# 输出为：全国计算机

print("{1}：{0:.6f}".format(3.1415926,"pi"))
# 输出为：pi：3.141593

Day 3

8 组合数据类型

组合数据类型主要分为集合类型、序列类型、映射类型

8.1 集合类型 - set

Python i语言中的集合类型与数学中的集概念一致。集合用来存储无序并且不重复的数据。集合中元素的类型只能是不可变数据类型，如：整数、浮点数、字符串、元组等。相比较而言，列表、字典、和集合类型本身都是可变数据类型。

例：S = {123， 3.14，"HelloWorld"， True}

集合也有他的操作符，和数学集合一样

集合类型常用操作方法

Q：创建一个空集合？

set1 = set()
# 而不是：set1 = {}    // 这样是一个字典类型

8.2 序列类型

序列类型用来存储有序并且可以重复的数据，分别为以下两种类型类型：列表（list) 元组（tuple）

8.2.1 列表类型 - list

索引 用来表示列表中元素的所在位置基于位置，可以快速找到其对应的列表元素如果一个列表中有n个元素，那么索引的取值范围是0~n-1 <列表或列表变量>[索引]

切片 可以获取列表指定索引区间的元素

<列表或列表变量>[开始索引：结束索引]

<列表或列表变量>[开始索引：结束索引：步长]

ls = [123,"123",3.14,"abc"]
# 打印为：[123, '123', 3.14, 'abc']
print(ls[::-1])    # 倒序排列

列表类型常用操作符与函数

列表类型常用操作方法

Q：创建一个空列表？

ls1 = list()
ls1 = []    
# 这样是一个字典类型

Q：如何复制一个新列表？

ls1 = [123,321,1234567]
ls2 = ls1
ls2[1] = 3.14
print(ls1,ls2)
# 输出为：[123, 3.14, 1234567] [123, 3.14, 1234567]

很明显，ls1输出出现了问题，按理来说应该是 [123,321.1234567]

可结果是 [123, 3.14, 1234567] 这是为什么呢？

这里我们就要提到计算机底层方面的 堆栈 与 静态存储区 ，我用一张图来表示：

所以如何正确复制一个新列表？

ls1 = [123,321,1234567]
ls2 = ls1.copy()
ls2[1] = 3.14
print(ls1,ls2)
# 输出为：[123, 321, 1234567] [123, 3.14, 1234567]

8.2.2 元组类型

元组一旦定义就不能修改元组类型使用()来表示，例：t = (123，3.14,123,"abc")

以下是常用操作符与函数

8.3 字典类型

字典类型数据主要以“键值对”的形式存储，类似汉语字典的目录形式。具体定义格式如下：{<键1>:<值1>，<键2>:<值2>，....，<键n>:<值n>}

以下为常用的操作函数：

字典类型常用操作方法

配合 for 循环进行操作

d = {"student":[{"name":"唐僧"},{"name":"孙悟空"},{"name":"猪八戒"},{"name":"沙悟净"}]}  
for i in d["student"]:  
    print(i["name"])  
    print(i)

# 输出为
"""
唐僧
{'name': '唐僧'}
孙悟空
{'name': '孙悟空'}
猪八戒
{'name': '猪八戒'}
沙悟净
{'name': '沙悟净'}
"""

# 当然我们也可也这样：

d2 = {"20240101":"张伟","20240102":"李华","20240103":"王强"}
for i in d2.values():
    print(i)
    # 输出姓名列 张伟...

for i in d2.items():
    print(i)
    # 输出元组列 ("20240101","张伟")...
    print(i[1])
    # 输出姓名列 张伟...

for k,v in d2:
    print(v)
    # 输出为姓名列 张伟...

9 文件的处理

操作流：打开文件（open（））->读/写->关闭文件（close（））

• 文本文件

一般由单一特定编码的字符组成，如Unicode编码，内容容易统一展示和阅读，由于文本文件存在编码，可以看作是存储在磁盘上的长字符串，如一个txt格式的文本文件。

• 二进制文件

直接由0和1组成，没有统一的字符编码，文件内部数据的组织格式与文件用途有关。如png格式的图片文件、mkv格式的视频文件。

区别： 是否有统一的字符编码

9.1 相对路径与绝对路径

总体来说和 PHP 的差不多，相对路径以程序路径作为参照物。

相对路径：path = "a/test.txt"

绝对路径：path = "D:/testFile/a/test.txt"

值得一提的是 Python 中的转义字符

9.2 打开文件

使用 open() 函数打开文件 <变量名> = open(<文件路径及文件名>，<打开模式>)

文件打开的常用组合

• 以文本方式只读打开一个文件，读入后不能对文件进行修改：r
• 以文本方式可读写地打开一个文件，可以读入并修改文件：r+
• 以文本方式打开一个空文件，准备写入一批内容，并保存为新文件：w
• 以文本方式打开一个空文件或已有文件，追加形式写入一批内容，更新原文件：a+
• 以二进制方式只读打开一个文件，读入后不能对文件进行修改：rb

9.2 文件读取

这里我们需要关注也有个易错点

path = "a/test.txt"
f = open(path, "r", encoding="UTF-8")
s = f.read()
print(s)

ls = f.readlines()
print(ls)
f.close()

# 结果输出 大家好，欢迎！\n里面请！\n []

为什么我们读取文件后再输出列表就输出为空列表呢？这里就不得不提到 “指针” 了。指针是什么？就类似于光标，我已一次读取的时候指针以及在文本末尾了，第二次读取就是从文本末尾读取，当然读取不到东西，这里我们就需要用到 seek() 方法了！

path = "a/test.txt"
f = open(path, "r", encoding="UTF-8")
s = f.read()
print(s)

f.seek(0)
ls = f.readlines()
print(ls)
f.close()

9.3 文件写入

例如：

f = ...
f.writelines("["123123", "321321"]")
# 存储就是一行一个

9.4 数据的读取与存储

9.4.1 一维数据

一维数据就如他名字所说的，一般用一些特定符号进行分割数据，例如（“ ”、“；”、“\n”）等等。储存形式为 Csv 不如 json 方便 下面为一个一维数据例子：

Android手机.csv：小米；华为；OPPO；VIVO

考试中一般配合 splite() 函数方法食用！

易错题：

列表ls = [1,2,3,4,5,6,[7,8,9]]，以下选项中描述正确的是（    A    ）

A.ls 可能是一维列表            B.ls 可能是二维列表

C.ls 可能是多维列表            D.ls 可能是高维列表

9.4.2 二维数组

这里需要多加练习了， 摘录一个将 CSV 转换成列表的例子

File：student.scv

姓名, 性别, 年龄
李华,男,18
王强,女,19
翠翠,女,20

f = open("students.csv", "r")
student = []
for line in f:
    line = 1ine.strip("\n")    #去除换行符
    temp = 1ine.split(",")
    student.append(temp)
f.close()
print(student)

# 输出：[[“姓名”,“性别”,“年龄”],[“李华”,“男”,“18”],...]

10 Python 模块/库的使用

10.1 内置函数

10.2 模块的引用

import

• import <模块名> as <别名>

from ... import ...

• from <模块名> import <对象、函数>

# import 引用
import test1 as t

test1.fuc()
t.fuc()

# 如果不想要test1 或者 t 
# 可以用form ... import ...  引用（ * 所有引用）
from test1 import fuc, add 

fuc()
add()
plus()    # 这样就不行，因为 import 没提及！

10.3 标准库的使用

10.3.1 turtle —— 海龟绘图

使用 海龟绘图 可以编写重复执行简单动作的程序画出精细复杂的形状。在 Python 中，海龟绘图提供了一个实体“海龟”形象（带有画笔的小机器动物），假定它在地板上平铺的纸张上画线。

10.3.1-1 窗体函数

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

width：窗口宽度

height：窗口高度

startx：窗口与屏幕左侧距离（单位象素）

starty：窗口与屏幕顶部距离（单位象素）

10.3.1-2 画笔运动命令

10.3.1-3 画笔控制命令

10.3.1-4 全局控制命令

Example 1.

画一个八边形

import turtle as t

t.setup(600,600,20,20)

for i in range(8):
    t.forward(50)
    t.right(45)

10.3.2 random —— 伪随机数

Python 的随机算法采用 梅森旋转算法

10.4 第三方库的使用

10.4.1 第三方库的安装

第三方库的安装主要是三种方式，pip工具安装、自定义安装、文件安装（扩展名.whl)

10.4.1-1 pip 工具的使用

pip <命令> <选项>

安装：install 库名

卸载：uninstall 库名

下载：download 库名

查看当前第三方库列表：list

查看某个第三方信息：show

10.4.2 jieba 库

jieba（“结巴”）是Python中一个重要的第三方中文分词函数库，能够将一段中文文本分割成中文词语的序列，jieba库需要通过 pip 指令安装。

10.4.2-1 常用函数

import jieba

test_content = '迅雷不及掩耳盗铃儿响叮当仁不让世界充满爱之势' 

cut_res = jieba.lcut(test_content) 
print(list(cut_res))

cut_res = jieba.lcut(test_content, cut_all=True) 
print(list(cut_res))

# ['迅雷不及', '掩耳盗铃', '儿响', '叮', '当仁不让', '世界', '充满', '爱之势']
# ['迅雷', '迅雷不及', '迅雷不及掩耳', '不及', '掩耳', '掩耳盗铃', '儿', '响叮当', '叮当', '当仁不让', '不让', '世界', '充满', '爱', '之', '势']

Python 二级考试只需要了解这么多，更多详细了解：jieba，为中文分词而生的Python库 —— 知乎

10.4.3 其他第三方库

Day 4

第四天 Python 二级所考的知识点已全部学完，下面是刷题部分！