Python3的简单语法与常用库（慢慢更新中）

参考链接： Python | 抓取网页并获得最常用单词的程序

之前学习Python的时候，主要是在网上简单看了些文档，并没有系统的去学习过，前些天抽空在中国大学MOOC上学习了由北京理工大学嵩天老师讲授的免费公开课--Python语言程序设计。这个课程讲的比较基础，但讲的确实不错。 

本文档主要就是总结下Python的基础语法与公开课中讲到的一些简单库的使用以及一些代码示例，方便以后需要的时候查看（通过右侧目录直接跳转到你需要查看的位置）。 

常用基础语法 

条件判断 

单分支结构 

# if 条件语句 ：

#     语句块

if 1 < 2 :

    print("满足条件") 

二分支结构 

# if 条件语句 :

#     语句块1

# else:

#     语句块2

if 'a' > 'b' :

    print("满足条件")

else:

    print("不满足条件") 

紧凑二分支表达形式 

# 表达式1 if 条件 else 表达式2

print("猜{}了".format("对" if 2 > 1 else "错")) 

多分支结构 

# if 条件1 :

#     语句块1

# elif 条件2 :

#     语句块2    

#   ..... 

# else :

#     语句块n

a = 3

if a == 1:

    print("1")

elif a == 2:

    print("2")

elif a == 3:

    print("3")

else:

    print("?????") 

异常处理 

简单的异常处理如下，首先执行try中的语句，如果中途报错则执行except中的指令，否则不执行。 

try:

    num = eval(input("请输入一个整数："))

    print(num**2)

except:

    print("输入不是整数") 

下面在提供一种捕获异常的方法，当你不确定会遇到哪种错误类型时可以使用，遇到错误后会打印错误信息并退出程序： 

try:

    somecode

except Exception as e:

    print(e)

    exit(1) 

下面是异常处理的高级使用： 

# finally对应的语句4一定会执行，else对应的语句3在不发生异常时执行

try:

    <语句1>

except:

    <语句2>

else:

    <语句3>

finally:

    <语句4> 

循环结构 

在python中，for循环常用遍历某个结构，形成循环运行方式： 

# for <循环变量> in <遍历结构> :

#    <语句块>

for i in range(5):  # i从0遍历到4

    print(i)

for i in range(1,6,2): # i从1遍历到6，间隔为2

    print("hello", i)

for c in "python": # 遍历字符串'p','y','t','h','o','n'

    print(c)

for item in [1, "hello", 6, "你好"]: # 遍历列表

    print(item)

for line in fi: # fi是一个文件标识符，遍历其每行

    <语句块> 

while循环： 

a = 3

while a > 0:

    a = a - 1

    print(a) 

循环保留字：continue, break 

循环的高级用法：当循环没有被break语句退出时，执行else语句，else语句作为“正常”完成循环的奖励。 

for <变量> in <遍历结构>:

    <语句块1>

else:

    <语句块2>

while <条件>:

    <语句块1>

else:

    <语句块2> 

常用数据类型及方法 

数字类型及操作 

python中的数字类型主要包括整数类型，浮点数类型，复数类型。 

整数类形，四种进制表示形式： 

十进制， 1010, 99, -217

二进制， 以0b或0B开头： 0b101, -0B100

八进制， 以0o或0O开头： 0o123，-0O456

十六进制， 以0x或0X开头： 0x9a，-0X89 

浮点型，运算过程中存在不确定尾数，浮点型可采用科学计算法表示，以字母e或者E作为幂的符号，以10位基数表示 

# 0.0043

1.3e-3 

复数类型，与复变函数所学内容一致 

# 其中实部为1.23e可通过z.real获得，5.6e89为虚部可通过z.imag获得

z = 1.23e-4 + 5.6e89j 

常用运算操作 

 除了常用的加、减、乘、除（+ - * /）外，还有（//）整数除，（%）求余，（**）幂运算 

# 幂运算，2的3次方，与2**3的作用一样

pow(2,3)

# 四舍五入，对x四舍五入，d是小数截取位数若不填默认为0，

# round(10.126, 2) 为 10.13，round(1.6)为2

round(x, d)

# 下列为求绝对值、最大值、最小值操作

abs(x)

max(x1, x2, x3)

min(x1, x2, x3)

# 求商余，返回输出商和余数(x//y, x%y)

# divmod(10, 3) 结果为 (3,1)

divmod(x, y)

# 转型

int(x)

float(x)

complex(x) 

集合类型及操作 

集合类型与数学中的集合概念一致，集合中每个元素都是唯一的不存在相同的元素，且无序（故无法更改）。由于集合中每个元素都是唯一的，故集合方法常用于去重。 

# 使用{}建立集合，注意，不能使用该方法建立空集合，否则为空字典

A = {"Python", 123, "你好"}  

# 使用set建立集合

B = set("pypy123")  # {'1', 'y', '2', 'p', '2'} 无序且自动去除了重复的元素 

下图展示了常用的集合操作符： 

下面展示了常用的集合处理方法： 

S表示为一个集合 

S.add(x)若x不在集合中，将x添加到S中S.discard(x)移除S中元素x，如果x不在S中，不报错S.remove(x)移除S中元素x，如果x不在S中，产生KeyError异常S.clear()移除S中所有元素S.pop()随机返回S中一个元素，更新S，若S为空产生KeyError异常S.copy()返回S的一个副本len(S)返回集合的元素个数x in S判断x是否是集合S中的元素，是返回True否则Falseset(x)将其他类型变量x转变为集合类型，用于去重

序列类型及操作 

序列是一个基类类型，包括元组型、字符串类型以及列表类型。通用操作符以及通用函数方法如下图： 

元组类型 

元组是一种序列类型，一旦创建就不能被修改。使用小括号()或tuple()创建，可以使用也可以不使用小括号，元素间用逗号分隔。 

creature = "cat", "dog", "human"   # ('cat', 'dog', 'human')

color = (0x001100, "blue", creature) # (4352, 'blue', ('cat', 'dog', 'human'))

color[0]  # 4352

color[-1][2] # 'human' 

列表类型 

列表是一种序列类型，创建后可以随机被修改，使用方括号[]或list()创建，元素间用逗号分隔，列表无长度限制。 

ls = ['cat', 'dog', 1024] 

函数或方法描述ls[i] = x替换列表ls第i个元素为xls[i : j : k] = lt用列表lt替换ls切片后所对应元素子类表del ls[i]删除列表ls中第i个元素del ls[i : j : k] 删除列表ls中第i到第j以k为步长的元素ls += it更新列表ls，将列表lt元素增加到列表ls中ls *= n更新列表ls，其元素重复n次

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

字符串类型及操作 

字符串由一对单引号或一对双引号表示（三引号也可以），字符串是字符的有序序列，可以对其中的字符进行索引。 

str = "请输入带有符号的温度值："

str[0]    # '请'

str[-1]   # ':'

str[:2]  # '请输入'

str[1:5:3] # '输有'

str[::-1] # ':值度温的号符有带入输请' 

常用的转义符："\b"回退， "\n"换行， "\r"回车（光标移动到本行首） 

操作符及使用                                        描述 x + y连接两个字符串x和yn * x 或 x * n复制n次字符串x in s如果x是s的字串，返回True，否则False

函数及使用描述len(x)长度，返回字符串的长度str(x)任意类型x所对应的字符串形式hex(x) 或 oct(x)整数x的十六进制或者八进制小写形式字符串ord(x)x为字符，返回其对应的的Unicode编码chr(u)u为Unicode编码，返回其对应的字符

字符串方法及使用描述str.replace(old, new)返回字符串str副本，所有old字串被替换为newstr.center(width[, fillchar]) 字符串str根据宽度width居中，fillchar可选          "python".center(20, "=") 结果为         '==========python==========' str.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符str.join(iter) 在iter变量除最后元素外每个元素后增加一个str                   ",".join("123") 结果为            '1, 2, 3'   # 主要用于字符串分隔 str.lower() 或 str.upper()返回字符串的副本，全部字符大写或小写str.split(sep=None) 返回一个列表，由str根据sep被分割的部分组成        "A, B, C".split(",") 结果为 ['A', 'B', 'C'] str.count(sub)返回字串sub在str中出现的次数

字符串类型的格式化： 

格式化是对字符串进行格式表达的方式，用法为：<模板字符串>.format(<逗号分隔的参数>) 

# 若槽{}中内容为空，按默认顺序排列

# '2019-9-13:计算机C的CPU占用率为10%'

"{}:计算机{}的CPU占用率为{}%".format("2019-9-13", "C", 10)

# 'C:计算机2019-9-13的CPU占用率为10%'

"{1}:计算机{0}的CPU占用率为{2}%".format("2019-9-13", "C", 10)

# 1.12

"{0:.2f}".format(1.12346)

字典类型及方法 

字典包含了键（索引）与值（数据）的一种映射关系。采用大括号{}和dict()创建，键值之间用冒号分隔，键值对之间是无序的。 

d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}

d["中国"]   # 北京

"中国" in d  # True

d.keys()  # dict_key(['中国', '美国', '法国'])

d.values()  # dict_values(['北京', '华盛顿', '巴黎'])

# 是不是很像之前的集合，这就是为什么不能通过{}定义空集合的原因

de = {}  # type(de) <class 'dict'> 

函数的定义与使用 

函数名的定义 

函数是一段具有特定功能的、可重用的语句组。它有降低编程难度和代码复用两个作用。注意函数返回的是元组类型。 

def <函数名>(<参数(0个或多个)>) :

    <函数体>

    return <返回值>

# 定义一个计算数字n！的函数

def fact(n) :

    s = 1

    for i in range(1, n+1)

        s *= i

    return s

# 调用函数计算10！

fact(10) # 3628800

# 可变参数传递，函数定义时可以设计可变参数，即不确定参数总数量

def <函数名>(<参数>, *b) :

    <函数体>

    return <返回值>

# 定义一个连乘操作

def fact(n, *b) :

    s = n

    for item in b:

        s *= item

    return s

fact(2,3,4,5) # 120

# 定义指定类型的输入输出函数

def function(nama: str, age int) -> str:

    pass

    return "string" 

关于函数的局部变量和全局变量不在此细说，但需要注意两点：（1）若想在函数内部使用全局变量使用global保留字（2）局部变量为组合数据类型且未创建，等同于全局变量。 

ls = ["F", "f"]  # 在函数外创建了一个全局变量列表ls

def func(a) :

    ls.append(a)  # 此处的ls是列表类型，未真实创建等同于全局变量

    return

func("C")

print(ls)  # ['F', 'f', 'C'] 

lambda函数 

lambda函数是一种匿名函数，即没有名字的函数，常用于定义简单能够用一行表示的函数。（建议还是老老实实使用def函数） 

<函数名> = lambda <参数>: <表达式>

f = lambda x, y : x + y

f(10, 15)  # 25

递归函数 

函数定义中调用函数自身的方式，递归函数拥有两个关键特征：链条与基例。链条：计算过程存在递归链条。基例：存在一个或多个不需要再次递归的基例。下面给出三个简单的实例，在本文最后有一个利用递归函数绘制科赫雪花的实例，很有趣。 

# 计算n！

def fact(n):

    if n == 0:

        return 1  # 基例

    else:

        return n*fact(n-1)  # 链条

# 将字符串反转

def rvs(s):

    if s == "":

        return s  # 基例

    else:

        return rvs(s[1:]) + s[0]  # 链条

# 计算斐波那契数列

def f(n):

    if n == 1 or n == 2:

        return 1  # 基例

    else:

        return f(n-1) + f(n-2)  # 链条 

文件的使用 

文件是存储在辅助器上的数据序列，文件展现形态主要有两种：文本文件和二进制文件。文本文件是由单一特定编码组成的文件，如UTF-8编码。二进制文件直接由比特0和1组成，没有统一字符编码。 

# 文本形式打开文件

tf = open("f.txt", "rt")  # 以文本打开f.txt文件

print(tf.readline())  # 读取一行内容

tf.close()

# 二进制形式打开文件

bf = open("f.txt", "rb")  # 以二进制形式打开文件

print(bf.readline())

bf.close() 

 文件内容的读取：示例中文本只有一行文字“中国是一个伟大的国家” 

操作方法描述f.read(size=-1) 读入全部内容，如果给出参数，读入前size长度 >>>s = f.read(2) 中国 f.readline(size=-1) 读入一行内容，如果给出参数，读入该行前size长度 >>>s = f.readline() 中国是一个伟大的国家 f.readlines(hint=-1) 读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行 >>>s = readlines() ['中国是一个伟大的国家 '] 

# 文件的逐行操作

fname = input("请输入要打开的文件名称")

fo = open(fname, "r")

for line in fo.readlines():  # 一次读入，分行处理

    print(line)

fo.close

fname = input("请输入要打开的文件名称")

fo = open(fname, "r")

for line in fo:  # 分行读入，逐行处理

    print(line)

fo.close 

文件内容的写入 

操作方法描述f.write(s) 向文件写入一个字符串或字符流 >>>f.write("中国是一个伟大的国家") f.writelines(lines) 将一个元素全为字符串的列表写入文件 >>>ls = ["中国", "法国", ''美国"] >>>f.writelines(ls) f.seek(offset) 改变当前文件操作指针的位置，offset含义如下： 0-文件开头； 1-当前位置； 2-文件结尾 >>>f.seek(0)  # 回到文件开头 

简单库的使用 

turtle库的使用 

turtle是一个入门级的图形绘制函数库。使用前记得import，建议import turtle as tt，名字太长了。下图（来自嵩天老师的PPT）给出了turtle的窗体结构以及空间坐标体系。使用过程中一定要注意海龟的朝向。 

 下面给出了常用的一些函数以及注释： 

# 设置turtle的窗体位置以及大小，其中startx和starty是可选参数，窗口默认是在屏幕的中央

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

# 将笔抬起，抬起后移动是不会留下印记

turtle.penup()

# 将笔放下

turtle.pendown()

# 设置笔的像素宽度

turtle.pensize(w)

# 将海龟(笔)移动到指定坐标，移动过程中海龟的朝向是不变的

turtle.goto(x, y)

# 海龟向前移动

turtle.fd(d)

# 海龟向后移动

turtle.bk(d)

# 海龟转动，r为转动圆弧的半径，angle为转动角度，以海龟左侧为正角度方向

turtle.circle(r, angle)

# 改变海龟的行进方向，只改变方向不会前进，以海龟左侧为正角度方向

turtle.seth(angle)

# 左转或右转

turtle.left(angle)

turtle.right(angle)

# 设置RGB色彩模式，1.0为RGB小数值模式，255为RGB整数值模式，默认为小数值模式

turtle.colormode(mode) 

time库的使用 

time库是python中处理时间的标准库，记得import time 

# 获取当前时间戳，计算机内部时间值，是一个浮点数

time.time()  # 1568360352.4165237

# 获取当前时间并以易读方式表示，返回是个字符串

time.ctime()  # 'Fri Sep 13 15:40:41 2019'

# 获取当前时间，表示为计算机可处理的时间格式

# time.struct_time(tm_year=2019, tm_mon=9, tm_mday=13, tm_hour=7, tm_min=41, tm_sec=30, tm_wday=4, tm_yday=256, tm_isdst=0)

time.gmtime() 

# 时间格式化，按照定义输出效果

# '2019-09-13 07:48:54'

t = time.gmtime()

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

# 返回一个CPU级别的精确时间计数值，单位为秒，计数的起点不确定，所以要连续调用才有意义

# 通常连续两用两次计算其时间差

start = time.perf_counter()

end = time.perf_counter()

end - start  # 时间差

# 程序等待s秒

time.sleep(s) 

random库的使用 

random库是使用随机数的Python标准库 

需要说一下random中的随机数种子seed，可以理解为生成随机序列的一种规则，相同的随机数种子生成的随机数顺序一样，使得随机实验具有可重复性。一般可不设置这个参数，这个参数默认为当前系统时间，所以能够保证生成的随机性。 

# 设置生成随机数种子

random.seed(10)

# 生成一个[0, 1)之间的随机小数

random.random()

# 生成一个[a, b]之间的随机整数

random.randint(a, b)

# 生成一个[m, n)之间以k为步长的随机整数

random.randrange(m, n[, k])  // random.randrange(10, 100, 10)

# 生成一个k比特长的随机整数

random.getrandbits(k)

# 生成一个[a, b]之间的随机小数

random.uniform(a, b)

# 从序列中随机选择一个元素

random.choice([1, 2, 3, 5])

# 将序列中的元素随机排序

random.shuffle([1, 5, 6, 8]) 

jieba库的使用 

jieba是一个优秀的中文分词第三方库（需要在命令行中pip install jieba进行安装）。jieba库由三种分析模式精确模式、全模式以及搜索引擎模式（常用精确模式）。 

精确模式：把文本精确的切开，不存在冗余单词。 

全模式：把文本中所有可能的词语都扫描出来，有冗余。 

搜索引擎模式：在精确模式基础上，多长词再次切分。 

函数描述jieba.lcut(s) 精确模式，返回一个列表类型的分词结果 >>>jieba.lcut("中国是一个伟大的国家") ['中国', '是', '一个', '伟大', '的', '国家'] jieba.lcut(s, cut_all=True) 全模式，返回一个列表类型的分词结果，存在冗余 >>>jieba.lcut("中国是一个伟大的国家", cut_all=True) ['中国', '国是', '一个', '伟大', '的', '国家'] jieba.lcut_for_search(s) 搜索引擎模式，返回一个列表类型的分词结果，存在冗余 >>>jieba.lcut_for_saerch("中华人名共和国是伟大的") ['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', 的''] jieba.add_word(w) 向分词词典增加新词w >>>jieba.add_word("蟒蛇语言") 

在本文的示例代码部分，有使用jieba库对三国演义中人物出场次数的统计实例。 

PyInstaller库的使用 

pyinstaller是一个用来打包的第三方库（pip install pyinstaller），将.py源代码转换成无需源代码的可执行文件（适用Windows、Linux以及Mac OS X系统）。使用也很简单，打开命令行进入py文件所在目录，输入以下指令即可打包成一个可执行文件： 

pyinstaller -F <文件名.py> 

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

wordcloud库的使用 

wordcloud库是一个优秀的词云展示第三方库（pip install wordcloud），什么是词云见下图，wordcloud.WordCloud()代表一个文本对应的词云，词云可根据文本词语出现的频率等参数绘制词云，词云的绘制形状、尺寸和颜色都可以设定。 

这个库用起来很简单，就三个步骤：（1）配置对象参数（2）加载词云文本（3）输出词云文件。注意：文本是以空格分割单词，若使用中文需预先对文本进行分词。 

import wordcloud

c = wordcloud.WordCloud()  # 配置对象参数

c.generate("wordcloud by python")  # 加载词云文本

c.to_file("pywordcloud.png")  # 输出词云文件 

下面介绍下配置对象的详细参数： 

参数描述width，height 指定词云对象生成图片的大小，默认是宽400个像素高200个像素 >>>w=wordcloud.WordCloud(width=600, height=400) min_font_size 指定词云中字体的最小字号，默认4号 >>>w=wordcloud.WordCloud(min_font_size=10) max_font_size 指定词云中字体的最大字号，根据高度自动调整 >>>w=wordcloud.WordCloud(max_font_size=20) font_step 指定词云中字体字号的步进间隔，默认为1 >>>w=wordcloud.WordCloud(font_step=2) font_path 指定字体文件的路径，默认None >>>w=wordcloud.WordCloud(font_path="msyh.ttc") max_words 指定词云显示的最大单词数量，默认为200 >>>w=wordcloud.WordCloud(max_words=20) stop_words 指定词云的排除词列表，即不显示的单词列表 >>>w=wordcloud.WordCloud(stop_words={"python"}) mask 指定词云形状(图像背景必须是纯白色)，默认为长方形，需要引用imread()函数 >>>from scipy.misc import imread >>>mk=imread("pic.png") >>>w=wordcloud.WordCloud(mask=mk) background_color 指定词云图片的背景颜色，默认为黑色 >>>w=wordcloud.WordCloud(background_color="white") 

import jieba

import wordcloud

from scipy.misc import imread

mk = imread("pic.png")

txt = "程序设计语言是计算机能够理解和\

    识别用户操作议图的一种交互体系，它按照\

    特定规则组织计算机指令，使计算机能够自\

    动进行各种运算处理"

w = wordcloud.WordCloud(width=1000, height=700\

    font_path="msyh.ttc, mask=mk")

w.generate(" ".join(jieba.lcut(txt)))  # 中文需要先分词并组成空格分割字符串

w.to_file("pywcloud.png") 

os库的使用 

os库提供通用的、基本的操作系统交互功能（包括windows、mac os以及linux）。os库包括路径操作、进程管理以及环境参数。 

os.path子库，处理文件路径及信息： 

函数描述os.path.abspath(path) 返回path在当前系统中的绝对路径 >>>os.path.abspath("file.txt") 'D:\\python\\file.txt' os.path.normpath(path) 归一化path的表示形式，统一用\\分隔路径 >>>os.path.normpath("D://python//file.txt") 'D:\\python\\file.txt' os.path.relpath(path) 返回当前程序与文件之间的相对路径（relative path） os.path.dirname(path) 返回path中的目录名称 >>>os.path.dirname("D://python//file.txt") "D://python" os.path.basename(path) 返回path中最后的文件名称 >>>os.path.basename(”D://pyhton//file.txt“) "file.txt" os.path.join(path, *paths) 组合path和paths，返回一个路径字符串 >>>os.path.join("D:/", "python/file.txt") 'D:/python/file.txt' os.path.exists(path) 判断path对应文件或目录是否存在，返回True或False os.path.isfile(path) 判断path所对应是否为已存在的文件，返回True或False os.path.isdir(path) 判断path所对应是否为已存在的目录，返回True或False os.path.getatime(path) 返回path对应文件或目录上一次的访问时间 os.path.getmtime(path) 返回path对应文件或目录最近一次的修改时间 os.path.getctime(path) 返回path对应文件或目录的创建时间 os.path.getsize(path) 返回path对应文件的大小，以字节为单位  

os.system(command),执行程序或命令command 

import os

os.system("C:\\Windows\\System32\\calc.exe")  # 打开计算器

os.system("C:\\Windows\\System32\\mspaint.exe \

    D:\\python\\grwordcloud.png")  # 用电脑上的图画程序打开png图片 

os库环境参数 ，获取或改变系统环境信息 

函数描述os.chdir(path)修改当前程序操作的路径os.getcws()返回程序的当前路径os.getlogin()获得当前系统登录用户名称os.cpu_count()获得当前系统的CPU数量os.urandom(n)获得n个字节长度的随机字符串，通常用于加解密运算

示例代码 

使用turtle库绘制小蟒蛇示例 

import turtle

# 设置窗口在屏幕中的位置以及大小 (width, height, startx, starty)

turtle.setup(650, 350, 200, 200)

# turtle抬起不会绘制轨迹

turtle.penup()

# fd表示正前方向

turtle.fd(-250)

# turtle放下开始绘制轨迹

turtle.pendown()

# 画笔宽度

turtle.pensize(25)

turtle.pencolor("purple")

# 改变turtle的行进方向（angle）

turtle.seth(-40)

for i in range(4):

    # 以turtle左侧为圆心绘制（r, angle）

    turtle.circle(40, 80)

    turtle.circle(-40, 80)

turtle.circle(40, 80/2)

turtle.fd(40)

turtle.circle(16, 180)

turtle.fd(40 * 2/3)

turtle.done() 

使用递归函数和turtle库绘制小雪花示例 

import turtle as tl

def koch(size, n):

    if n ==0:

        tl.fd(size)

    else:

        for angle in [0, 60, -120, 60]:

            tl.left(angle)

            koch(size/3, n-1)

def main():

    tl.setup(600, 600)

    tl.penup()

    tl.goto(-200, 100)

    tl.pendown()

    tl.pensize(2)

    level = 4

    koch(400, level)

    tl.right(120)

    koch(400, level)

    tl.right(120)

    koch(400, level)

    tl.hideturtle()

main()

使用文本格式输出进度条示例 

import time

scale = 50

print("执行开始".center(scale//2, "-"))

start = time.perf_counter()

for i in range(scale + 1):

    a = '*' * i

    b = '.' * (scale - i)

    c = (i/scale)*100

    dur = time.perf_counter() - start

    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur), end='')

    time.sleep(0.05)

print("\n" + "执行结束".center(scale//2, '-'))

使用jieba库统计三国演义人物出场次数示例 

import jieba

txt = open("threekingdoms.txt", "r", encoding="utf-8").read()

excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此", "商议", "如何"}

words = jieba.lcut(txt)

counts = {}

for word in words:

    if len(word) == 1:

        continue

    elif word == "诸葛亮" or word == "孔明曰":

        rword = "孔明"

    elif word == "关公" or word == "云长":

        rword = "关羽"

    elif word == "玄德" or word == "玄德曰":

        rword = "刘备"

    elif word == "孟德" or word == "丞相曰" or word == "丞相":

        rword = "曹操"

    else:

        rword = word

    counts[rword] = counts.get(rword, 0) + 1

for word in excludes:

    del counts[word]

items = list(counts.items())

items.sort(key=lambda x:x[1], reverse=True)

for i in range(10):

    word, count = items[i]

    print("{0:<10}{1:>5}".format(word, count)) 

使用wordcloud和jieba库分析文本生成词云 

import jieba

import wordcloud

from scipy.misc import imread

mask = imread("fivestart.jpg")

f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")

t = f.read()

f.close()

ls = jieba.lcut(t)

txt = " ".join(ls)

w = wordcloud.WordCloud(font_path="msyh.ttc", \

                        mask=mask, \

                        width=1000, height=700, \

                        background_color="white")

w.generate(txt)

w.to_file("grwordcloud.png")