全国青少年软件编程python五级(2021.12备考1)

#五级

>>> a_list = ['a', 'b', 'c', 'd', 'e']

>>> a_list = []                   #创建空列表

>>> list((3, 5, 7, 9, 11))        #将元组转换为列表

[3, 5, 7, 9, 11]

>>> list(range(1, 10, 2))         #将range对象转换为列表

[1, 3, 5, 7, 9]

>>> list(map(str, range(10)))     #将map对象转换为列表

['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

>>> list(zip('abcd', [1,2,3,4]))  #将zip对象转换为列表

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> list(enumerate('Python'))     #将enumerate对象转换为列表

[(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')]

>>> list(filter(str.isdigit, 'a1b2c3d456'))

                                    #将filter对象转换为列表

['1', '2', '3', '4', '5', '6']

>>> list('hello world')        #将字符串转换为列表

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

>>> list({3, 7, 5})            #将集合转换为列表，集合中的元素是无序的

[3, 5, 7]

>>> x = list()                 #创建空列表

>>> x = [1, 2, 3]

>>> del x                      #删除列表对象

>>> x                          #对象删除后无法再访问，抛出异常

NameError: name 'x' is not defined

>>> x = list('Python')            #把字符串转换为列表

>>> x

['P', 'y', 't', 'h', 'o', 'n']

>>> x[0]                          #下标为0的元素，第一个元素

'P'

>>> x[-2]                         #下标为-2的元素，倒数第二个元素

'o'

（1）append()、insert()、extend()

>>> x = [1, 2, 3]

>>> x.append(4)                      #在尾部追加元素

>>> x

[1, 2, 3, 4]

>>> x.index(3)                       #查看3在列表中的下标

2

>>> x.insert(0, 0)                   #在列表开始处插入元素0

>>> x

[0, 1, 2, 3, 4]

>>> x.index(3)                       #后面的元素自动向后移动，索引加1

3

>>> x.extend([5, 6, 7])              #在尾部追加多个元素

>>> x

[0, 1, 2, 3, 4, 5, 6, 7]

（2）pop()、remove()

>>> x = [1, 2, 3, 4, 5, 6, 7]

>>> x.pop()                       #删除并返回尾部元素

7

>>> x.pop(0)                      #删除并返回第一个位置的元素

1

>>> x

[2, 3, 4, 5, 6]

>>> x = [1, 2, 1, 1, 2]

>>> x.remove(2)                   #删除第一个值为2的元素

>>> x

[1, 1, 1, 2]

（3）count()、index()

>>> x = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

>>> x.count(3)                     #元素3在列表x中的出现次数

3

>>> x.index(2)                     #元素2在列表x中首次出现的索引

1

>>> x.index(5)                     #列表x中没有5，抛出异常

Traceback (most recent call last):

  File "<pyshell#26>", line 1, in <module>

    x.index(5)

ValueError: 5 is not in list

（4）sort()、reverse()

>>> x = list(range(11))                #包含11个整数的列表

>>> import random

>>> random.shuffle(x)                  #把列表x中的元素随机乱序

>>> x

[6, 0, 1, 7, 4, 3, 2, 8, 5, 10, 9]

>>> x.sort(key=lambda item:len(str(item)), reverse=True) 

                                       #按转换成字符串以后的长度

                                       #降序排列

>>> x

[10, 6, 0, 1, 7, 4, 3, 2, 8, 5, 9]

>>> x.sort(key=str)                    #按转换为字符串后的大小

                                       #升序排序

>>> x

[0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]

>>> x.sort()                           #按默认规则升序排序

>>> x

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> x.reverse()                        #把所有元素翻转或逆序

>>> x

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

（1）加法运算符+可以连接两个列表，得到一个新列表。

>>> x = [1, 2, 3]

>>> x = x + [4]

>>> x

[1, 2, 3, 4]

（2）乘法运算符*可以用于列表和整数相乘，表示序列重复，返回新列表。

>>> x = [1, 2, 3]

>>> x * 2

[1, 2, 3, 1, 2, 3]

（3）成员测试运算符in可用于测试列表中是否包含某个元素。

>>> 3 in [1, 2, 3]

True

>>> [3] in [1, 2, 3]

False

>>> x = list(range(11))           #生成列表

>>> import random

>>> random.shuffle(x)             #打乱列表中元素顺序

>>> x

[0, 6, 10, 9, 8, 7, 4, 5, 2, 1, 3]

>>> all(x)                        #测试是否所有元素都等价于True

False

>>> any(x)                        #测试是否存在等价于True的元素

True

>>> max(x)                        #返回最大值

10

>>> max(x, key=str)               #按指定规则返回最大值

9

>>> min(x)                        #最小值

0

>>> sum(x)                        #所有元素之和

55

>>> len(x)                        #列表元素个数

11

>>> list(zip(x, [1]*11))          #两个列表中的元素重新组合

[(0, 1), (6, 1), (10, 1), (9, 1), (8, 1), (7, 1), (4, 1), (5, 1), (2, 1), (1, 1), (3, 1)]

>>> list(zip(['a', 'b', 'c'], [1, 2]))

                                  #如果两个列表不等长，以短的为准

[('a', 1), ('b', 2)]

>>> list(enumerate(x))            #把enumerate对象转换为列表

                                  #也可以转换成元组、集合等等

[(0, 0), (1, 6), (2, 10), (3, 9), (4, 8), (5, 7), (6, 4), (7, 5), (8, 2), (9, 1), (10, 3)]

>>> list(' '.encode())        #encode()是字符串的方法

                                  #默认使用UTF8进行编码

>>> bytes(_)                      #把列表中的字节连接成为字节串

b'\xe8\x91\xa3\xe4\xbb\x98\xe5\x9b\xbd'

>>> _.decode()                    #decode()是字节串的方法

                                  #默认使用UTF8进行解码

' '

python列表推导式

使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。

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

#x=0-9

#x*x=0 1 4       81

aList = []

for x in range(10):

    aList.append(x*x)

    

aList = list(map(lambda x: x*x, range(10)))

#匿名函数再求x*x   序列 0-9

#在第一个格子里放1粒米，

2**0=1

#第二个格子里放2粒米，

2**1=2

#第三个格子里放4粒米，

2**2=4

第四个格子里放8粒米，

2**3=8

以此类推，后面每个格子里的米都是前一个格子里的2倍，

#一直把64个格子都放满。需要多少粒米呢？

sum([2**i for i in range(64)])

vec = [[1,2,3], [4,5,6], [7,8,9]] 

[num for elem in vec for num in elem] 

# for elem in vec:#   elem=[1,2,3]        elem= [4,5,6]     elem= [7,8,9]

#    for num in elem:#num=1 num=2 mum=3   num=4 num=5 num=6  num=7 num=8 num=9

#           num

#[1, 2, 3, 4, 5, 6, 7, 8, 9] 

vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

result = []

for elem in vec:

    for num in elem:

        result.append(num)

result

#[1, 2, 3, 4, 5, 6, 7, 8, 9]

vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

sum(vec, [])

#[1, 2, 3, 4, 5, 6, 7, 8, 9]

过滤不符合条件的元素

aList = [-1,-4,6,7.5,-2.3,9,-11]

[i for i in aList if i>0]

#for i in aList:

#       if i>0:

#           i

#[6, 7.5, 9]

scores = {"Zhang San": 45, "Li Si": 78, "Wang Wu": 40, "Zhou Liu": 96, "Zhao Qi": 65, "Sun Ba": 90, "Zheng Jiu": 78, "Wu Shi": 99, "Dong Shiyi": 60}

highest = max(scores.values())

highestPerson = [name for name, score in scores.items() if score == highest]

#for name, score in scores.items():#  "Zhang San"  45   "Li Si",78,  "Wang Wu", 40

#   if score == highest

#       name

>>> [(x, y) for x in range(3) for y in range(3)]

#for x in range(3):#0-2

#   for y in range(3):#0-2

#     (x, y)

#

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

#for x in [1, 2, 3]:

#   for y in [3, 1, 4]:

#       if x != y:

#           (x, y)

#[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

[[row[i] for row in matrix] for i in range(4)]

'''

for i in range(4):

    for row in matrix:

        row[i]

    

'''

#

[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]] 

list(zip(*matrix))    #序列解包

matrix=[ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

*matrix=[1, 2, 3, 4] [5, 6, 7, 8] [9, 10, 11, 12]

#[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)] 

>>> def f(v):

    

    if v%2 == 0:

            v = v**2

        else:

            v = v+1

        

return v

>>> [f(v) for v in [2, 3, 4, -1] if v>0]

#for v in [2, 3, 4, -1]:

#    if v>0:

#     f(v)

#[4, 4, 16]

>>> [v**2 if v%2 == 0 else v+1 for v in [2, 3, 4, -1] if v>0]

#for v in [2, 3, 4, -1]:

#    if v>0:

#      if v%2 == 0 :

#         v**2

#      else :

#         v+1

#[4, 4, 16]

#使用列表推导式生成100以内的所有素数

>>> [p for p in range(2, 100) if 0 not in [p%d for d in range(2, int(p**0.5)+1)]]

'''

for p in range(2, 100):

    for d in range(2, int(p**0.5)+1):

        p%d

        if 0 not

          p

        

'''

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

>>> import random

>>> x = [random.randint(1,100) for i in range(10)] #生成随机数

>>> list(map(lambda i: i+5, x))                               #所有元素同时加5

>>> x = [random.randint(1,10) for i in range(10)]

>>> y = [random.randint(1,10) for i in range(10)]

使用“=”将一个元组赋值给变量

>>>a_tuple = ('a', 'b', 'mpilgrim', 'z', 'example')

>>> a_tuple

('a', 'b', 'mpilgrim', 'z', 'example')

>>> a = (3)

>>> a

3

>>> a = (3,)                            #包含一个元素的元组，最后必须多写个逗号

>>> a

(3,)

>>> a = 3,                              #也可以这样创建元组

>>> a

(3,)

>>> x = () #空元组

使用tuple函数将其他序列转换为元组

>>> tuple('abcdefg')                          #把字符串转换为元组

('a', 'b', 'c', 'd', 'e', 'f', 'g')

>>> aList

[-1, -4, 6, 7.5, -2.3, 9, -11]

>>> tuple(aList)                                #把列表转换为元组

(-1, -4, 6, 7.5, -2.3, 9, -11)

>>> s = tuple()                                   #空元组

>>> s

()

使用del可以删除元组对象，不能删除元组中的元素

元组中的数据一旦定义就不允许更改。

元组没有append()、extend()和insert()等方法，无法向元组中添加元素。

元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。

从效果上看，tuple( )冻结列表，而list( )融化元组

元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，那么一般使用元组而不用列表。

元组对不需要改变的数据进行“写保护”将使得代码更加安全。

元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表永远不能当做字典键使用，因为列表不是不可变的。

可以使用序列解包功能对多个变量同时赋值

>>> x, y, z = 1, 2, 3                      #多个变量同时赋值

>>> v_tuple = (False, 3.5, 'exp')

>>> (x, y, z) = v_tuple

>>> x, y, z = v_tuple

>>> x, y, z = range(3)                   #可以对range对象进行序列解包

>>> x, y, z = iter([1, 2, 3])             #使用迭代器对象进行序列解包

>>> x, y, z = map(str, range(3))    #使用可迭代的map对象进行序列解包

>>> a, b = b, a                              #交换两个变量的值

>>> x, y, z = sorted([1, 3, 2])         #sorted()函数返回排序后的列表

>>> a, b, c = 'ABC'                        #字符串也支持序列解包

序列解包对于列表和字典同样有效

>>> s = {'a':1, 'b':2, 'c':3}

>>> b, c, d = s.items()

>>> b

(‘a’, 1)

>>> b, c, d = s                         #使用字典时不用太多考虑元素的顺序

>>> b

‘a'

>>> b, c, d = s.values()

>>> print(b, c, d)

1 2 3

序列解包遍历多个序列

>>> keys = ['a', 'b', 'c', 'd']

>>> values = [1, 2, 3, 4]

>>> for k, v in zip(keys, values):

  print((k, v), end=' ')

('a', 1) ('b', 2) ('c', 3) ('d', 4) 

>>> aList = [1,2,3]

>>> bList = [4,5,6]

>>> cList = [7,8,9]

>>> dList = zip(aList, bList, cList)

>>> for index, value in enumerate(dList):

    print(index, ':', value)

0 : (1, 4, 7)

1 : (2, 5, 8)

2 : (3, 6, 9)

Python 3.5还支持下面用法的序列解包

>>> print(*[1, 2, 3], 4, *(5, 6))

1 2 3 4 5 6

>>> *range(4),4

(0, 1, 2, 3, 4)

>>> {*range(4), 4, *(5, 6, 7)}

{0, 1, 2, 3, 4, 5, 6, 7}

>>> {'x': 1, **{'y': 2}}

{' 'x': 1 ,y': 2}

生成器推导式的结果是一个生成器对象。使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象__next__()方法或内置函数next()进行遍历，或者直接将其作为迭代器对象来使用。

生成器对象具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。

不管用哪种方法访问生成器对象，都无法再次访问已访问过的元素。

使用生成器对象__next__()方法或内置函数next()进行遍历

>>> g = ((i+2)**2 for i in range(10))     #创建生成器对象

>>> g

<generator object <genexpr> at 0x0000000003095200>

>>> tuple(g)                                         #将生成器对象转换为元组

(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)

>>> list(g)                                             #生成器对象已遍历结束，没有元素了

[] 

>>> g = ((i+2)**2 for i in range(10))      #重新创建生成器对象

>>> g.__next__()                             #使用生成器对象的__next__()方法获取元素

4

>>> g.__next__()                             #获取下一个元素

9

>>> next(g)                                      #使用函数next()获取生成器对象中的元素

16

使用for循环直接迭代生成器对象中的元素

>>> g = ((i+2)**2 for i in range(10))

>>> for item in g:                            #使用循环直接遍历生成器对象中的元素

       print(item, end=' ')

4 9 16 25 36 49 64 81 100 121 

>>> x = filter(None, range(20))       #filter对象也具有类似的特点

>>> 5 in x

True

>>> 2 in x                                        #不可再次访问已访问过的元素

False

>>> x = map(str, range(20))           #map对象也具有类似的特点

>>> '0' in x

True

>>> '0' in x                                       #不可再次访问已访问过的元素

False

切片是用来获取列表、元组、字符串等有序序列中部分元素的一种语法。在形式上，切片使用2个冒号分隔的3个数字来完成。

[start:end:step]

其中第一个数字start表示切片开始位置，默认为0；第二个数字end表示切片截止（但不包含）位置（默认为列表长度）；第三个数字step表示切片的步长（默认为1），省略步长时还可以同时省略最后一个冒号。另外，当step为负整数时，表示反向切片，这时start应该在end的右侧。

（1）使用切片获取列表部分元素

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[:]                 #返回包含原列表中所有元素的新列表

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[::-1]              #返回包含原列表中所有元素的逆序列表

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

>>> aList[::2]               #从下标0开始，隔一个取一个

[3, 5, 7, 11, 15]

>>> aList[3:6]               #指定切片的开始和结束位置

[6, 7, 9]

>>> aList[0:100]             #切片结束位置大于列表长度时，从列表尾部截断

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

（2）使用切片为列表增加元素

>>> aList = [3, 5, 7]

>>> aList[len(aList):] = [9]        #在列表尾部增加元素

>>> aList[:0] = [1, 2]              #在列表头部插入多个元素

>>> aList[3:3] = [4]                #在列表中间位置插入元素

>>> aList

[1, 2, 3, 4, 5, 7, 9]

（3）使用切片替换和修改列表中的元素

>>> aList = [3, 5, 7, 9]

>>> aList[:3] = [1, 2, 3]        #替换列表元素，等号两边的列表长度相等

>>> aList

[1, 2, 3, 9]

>>> aList[3:] = [4, 5, 6]        #切片连续，等号两边的列表长度可以不相等

>>> aList

[1, 2, 3, 4, 5, 6]

>>> aList[::2] = ['a', 'b', 'c'] #隔一个修改一个

>>> aList

['a', 2, 'b', 4, 'c', 6]

>>> aList[::2] = [1]              #切片不连续时等号两边列表长度必须相等

ValueError: attempt to assign sequence of size 1 to extended slice of size 3

（4）使用切片删除列表中的元素

>>> aList = [3, 5, 7, 9]

>>> aList[:3] = []                  #删除列表中前3个元素

>>> aList

[9]

例3-6  使用内置函数filter()和列表切片操作实现筛选法求指定范围内的素数。

maxNumber = int(input('请输入一个自然数：'))

lst = list(range(2, maxNumber))

#最大整数的平方根

m = int(maxNumber**0.5)

for index, value in enumerate(lst):

    #如果当前数字已大于最大整数的平方根，结束判断

    if value > m:

        break

    #对该位置之后的元素进行过滤

    lst[index+1:] = filter(lambda x: x%value != 0,

                             lst[index+1:])

print(lst)

turtle库

turtle(海龟)库是Python语言中一个很流行的绘制

图像的函数库。绘图时，以画布中心为坐标原点（

0,0），它根据一组函数指令的控制（如前进、后退、

旋转等），在这个平面坐标系中移动，从而在小海

龟爬行的路径上绘制了图形。

import turtle

turtle.函数名( )

from turtle import *

函数名( )

turtle库引例

from turtle import *

setup(800,600,100,100) #设置绘图区域的大小和起

始位置

pu() #抬画笔

fd(50) #前进50

pd() #放画笔

pensize(5) #线宽5磅

pencolor(“red”) #设置红色

for i in range(4): #重复4次，画4条边

fd(150)

left(90) #逆时针转90度

done() #结束

 画布函数

(1)screensize()函数：设置绘图区域的大小和背景色

turtle.screensize(800, 600, "green")

(2) setup()函数:设置绘图区域的大小和起始位置

turtle.setup(width=800, height=600, startx=100,

starty=100)

 画笔函数

(1)pensize()函数

语法：turtle. pensize (width=None )

功能：设置设置画笔的宽度

turtle. pensize (10)

(2) pencolor()函数

语法：turtle. pencolor (*args=None )

功能：设置设置画笔的颜色

pencolor("brown")

 画笔函数

(3)speed()函数

语法：turtle. speed ()

功能：设置画笔移动速度。

参数说明：参数speed范围[0,10]，需为整数，数字越

大越快，为0时表示不延迟。

 random库

Python内置的random库主要用于产生各种分

布的伪随机数序列。之所以称为伪随机数，是因

为该随机数是按照一定的算法产生的，当种子一

样时，随机数也是确定的、可预见的。

time库

time库是Python用于获取系统时间的内置库。使

用前需导入：import time。使用库函数方法：time.

方法()。

(1) time()函数

语法：time.time()

点数。该值为1970年1月1日后经过的浮点秒数。

>>> import time

>>> time.time()

1558921379.2954187

time库

(2) ctime()函数

语法：time.ctime()

功能：返回当前时间的字符串形式，为易读的当

前时间结果。

>>> time.ctime()

'Sat Feb 15 11:31:38 2020'

(3) gmtime()函数

语法：time.gmtime()

功能：获取当前时间，表示为计算机可处理的时间

格式。

>>> time.gmtime()

time.struct_time(tm_year=2020, tm_mon=2, tm_mday=15,

tm_hour=3, tm_min=34, tm_sec=0, tm_wday=5, tm_yday=46,

tm_isdst=0)

>>> t=time.gmtime()

>>> t.tm_year

2020

time库

(4) strftime()函数

语法：time. strftime (tpl，ts)

功能：tpl是格式化模板字符串，来定义输出效果

>>> t=time.gmtime()

>>> time.strftime("%Y-%m-%d %H:%M:%S" ,t)

'2020-02-16 02:25:37'

(5) strptime(str,tpl) ()函数

语法：time. strptime(str,tpl)

功能：将时间字符串变成时间的变量。其中，str是

字符串形式的时间值，tpl是格式化模板字符串，用

来定义输入效果。

>>> str="2020-02-15 11:56:30"

>>> time.strptime(str,"%Y-%m-%d %H:%M:%S")

time.struct_time(tm_year=2020, tm_mon=2,

tm_mday=15, tm_hour=11, tm_min=56, tm_sec=30,

tm_wday=5, tm_yday=46, tm_isdst=-1)

time库

(6) perf_counter()函数

语法：time. perf_counter

功能：返回一个CPU级别的精确时间计数值，单

位为秒。

>>> t1=time.perf_counter()

>>> t2=time.perf_counter()

>>> t2-t1

5.6052627730000495

(7) sleep()函数

语法：time. sleep(s)

功能：让程序休眠s秒，s可以是浮点数。

>>> time.sleep(3.3) #程序将在3.3秒后退出

jieba库

jieba 库是目前最好的 Python 中文分词组件，它

主要支持 3 种分词模式：全模式、精确模式、搜索

引擎模式。

jieba 库的分词原理是利用一个中文词库，将待

分词的内容与分词库进行比对，通过图结构和动态

规划法找到最大概率的词组。

全模式:参数cut_all为True，它试图将句子精确

地切开，适合文本分析，输出的是有多种可能

的分词组合。

我

是

一个

爱国

的

中国

人

结果：

>>> import jieba

>>> str='我是一个爱国的中国人'

>>> word1=jieba.cut(str,cut_all=True)

>>> for item in word1:print(item)

jieba库

Ø 精确模式：参数cut_all为False，在没有参数cut_all

的情况下，默认为精确模式。它把句子中所有的词

我

是

一个

爱国

的

中国

国人

结果：

>>> import jieba

>>> str='我是一个爱国的中国人'

>>> word2=jieba.cut(str,cut_all=False)

>>> for item in word2: print(item)

搜索引擎模式:使用cut_for_search方法，在精确

模式的基础上，对长词再次切分，提高召回率，

适合用于搜索引擎分词。

我

是

一个

爱国

的

中国

人

结果：

>>> import jieba

>>> str='我是一个爱国的中国人'

>>> word3 =

jieba.cut_for_search(str)

>>> for item in word3: print(item)

词性标注：使用jieba.posseg可以对词性进行标注。

我--r

是--v

一个--m

爱国--ns

的--uj

中国--ns

人—n

结果：

>>> import jieba.posseg

>>> word4 = jieba.posseg.cut(str)

>>> for item in word4:

print(item.word+"--"+item.flag)

jieba库－自定义词库

当分词系统无法识别有些新词时，可以通过

文件的形式自定义词库，分词前先行导入，然后

再正常分词。

jieba库－自定义词库分词示例

import jieba

import jieba.posseg

str="雷子是创新办主任，也是大数据方

面的专家"

word4= jieba.posseg.cut(str)

for item in word4:

print(item.word+"--"+item.flag)

jieba.load_userdict("D:/userdict.txt")

word5 = jieba.posseg.cut(str)

for item in word5:

print(item.word+"--"+item.flag)

worldcloud库

wordcloud库是专门用于根据文本生成词云的

Python第三方库，生成原理是以词语为单位，根据

其文本中出现的频率设计不同大小以形成视觉上不

同效果，而词云的大小、颜色、形状等都是可以设

定的，最终以图片的方式展示出效果。

worldcloud库示例

import wordcloud

w=wordcloud.WordCloud()

w.generate("I like Python and wordcloud")

w.to_file("D:/picture1.jpg")

使用字典保存26个英文字母和相应的频率（可以

使用随机函数生成），调用WordCloud类生成词云。

import wordcloud

import random

chars = [chr(x+ord('A')) for x in range(26)] #产生26个大写英文

字母

freq = [random.randint(1,100) for i in range(26)]

cf = {x[0]:x[1] for x in zip(chars,freq)} #打包成一个元组

print(cf) #输出每个字母出现的频率

wc = wordcloud.WordCloud()

wc.fit_words(cf)

wc.to_file("ex.png")

worldcloud库－指定形状生成词云示例

【例8-11】指定形状词云生成示例

wordcloud可以产生指定形状（以图像文件为约束）

的词云。先准备一个形状图像monkey.png，如图8-

12所示，并准备对应的一个故事文本monkey.txt。

生成效果如图8-13所示。

from wordcloud import WordCloud

import cv2

mask=cv2.imread('monkey.png')

f=open('monkey.txt','r',encoding='utf-8')

text=f.read()

wc =

WordCloud(background_color="white",\

width=800,\

height=600,\

max_words=200,\

max_font_size=80,\

mask=mask,\

).generate(text)

wc.to_file('monkey.jpg') 

Pyinstaller库

Pyinstaller是一个用于发布程序的第三方库，可以将Python源

文件（*.py）打包成可执行性文件。pip工具安装命令为：pip

install Pyinstaller。打包成可执行文件过程如下：

在CMD环境下，运行：Pyinstaller -F <源程序文件名>

执行结束后，会在C:\Users\Administrator下或源文件所在目录

下创建两个子文件夹：build和dist，其中可执行文件存放在dist文

件夹下，后面运行该文件时就没有任何依赖文件了。

C:\Users\Administrator> Pyinstaller -F "D:\\exp8-10.py"