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

之前学习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否则False
set(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个元素为x
ls[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最后增加一个元素x
ls.clear()	删除列表ls中所有元素
ls.copy()	生成一个新的列表，赋值ls中所有元素
ls.insert(i,x)	在列表ls的第i位置增加元素x
ls.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和y
n * 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字串被替换为new
str.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()创建，键值之间用冒号分隔，键值对之间是无序的（注意：python3.6后字典是有序的了）。

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