Python快速编程入门#学习笔记02# |第十章 ：Python计算生态与常用库（附.小猴子接香蕉、双人乒乓球小游戏源码）

学习目标

• 了解 Python计算生态及各应用领域的常用库
• 了解 Python生态库的构建与发布（module、package、lib）
• 了解 jieba、wordcloud、pygame库的基本用法
• 掌握 time、random、turtle库的基本用法

---

1. Python计算生态概述

1.1 Python计算生态概述

Python计算生态涵盖 以下多个领域，为各个领域的Python使用者提供了极大便利。

应用领域	说 明	常用库（框架）	功能说明
网络爬虫	网络爬虫是一种按照一定的规则，自动从网络上抓取信息的程序或者脚本。通过网络爬虫可以代替手工完成很多工作。	Requests 、 Python-Goose 、Re 、 Beautiful Soup 、Scrapy 、PySpider	网络爬虫程序涉及HTTP请求、Web信息提取、网页数据解析等操作，Python计算生态通过Requests Python-Goose Re Beautiful Soup Scrapy PySpider等库为这些操作提供了强有力的支持。
数据分析	数据分析指用适当的统计分析方法对收集来的大量数据进行分析，将它们加以汇总、理解与消化，以求最大化地发挥数据的作用。	Numpy 、 Pandas、 SciPy	数据分析离不开科学计算，Numpy 定义了表示N维数组对象的类型ndarray，通过ndarray对象可以便捷地存储和处理大型矩阵；包含了成熟的用于实现线性代数、傅里叶变换和随机数生成的函数，能以优异的效率实现科学计算。 Pandas 是一个基于Numpy开发的、用于分析结构化数据的工具集，它为解决数据分析任务而生，同时提供数据挖掘和数据清洗功能。Scipy是Python科学计算程序中会使用的核心库，它用于有效地计算Numpy矩阵，可以处理插值、积分、优化等问题，也能处理图像和信号、求解常微分方程数值
文本处理	文本指书面语言的表现形式，从文学角度说，文本是具有完整、系统含义的一个句子或多个句子的组合。文本处理即对文本内容的处理，包括文本内容的分类、文本特征的提取、文本内容的转换等等。	Jieba、 NLTK、 PyPDF2 、Python-docx	Jieba是一个优秀的Python中文分词库，它支持精确模式、全模式和搜索引擎模式这三种分词模式，支持繁体分词、自定义字典，可有效标注词性，从文本中提取关键词。NLTK提供了用于访问超过50个语料库和语汇资源的接口，支持文本分类、标记、解析和语法、语义分析等功能，简单、易用且高效，是最优秀的Python自然语言处理库。PyPDF2是一个专业且稳定的、用于处理PDF文档的Python库，它支持PDF文件信息的提取、文件内容的按页拆分与合并、页面裁剪、内容加密与解密等。Python-docx是一个用于处理Word文件的Python库，它支持Word文件中的标题、段落、分页符、图片、表格、文字等信息的管理，上手非常简单。
数据可视化	数据可视化是一门关于数据视觉表现形式的科学技术研究，它既要有效传达数据信息，也需兼顾信息传达的美学形式，二者缺一不可。	Matplotlib、Seaborn、Mayavi	Matplotlib 是一个基于Numpy开发的2D Python绘图库，该库提供了上百种图形化的数据展示形式。Matplotlib库中pyplot包内包含一系列类似MATLAB中绘图功能的函数，利用Matplotlib.pyplot，开发者编写几行代码便可生成可视化图表。Seaborn在Matplotlib的基础上进行了更高级的封装，支持Numpy和Pandas，但它比Matplotlib调用更简单，效果更丰富，多数情况下可利用Seaborn绘制具有吸引力的图表。Mayavi是一个用于实现可视化功能的3D Python绘图库，它包含用于实现图形可视化和处理图形操作的mlab模块，支持Numpy库。
图形用户界面	图形用户界面（Graphical User Interface，简称GUI）指采用图形方式显示的计算机操作用户界面，该界面允许用户使用鼠标、键盘等输入设备操纵屏幕上的图标或菜单选项，以选择命令、调用文件、启动程序或执行一些其他的日常任务。	PyQt5、WxPython、PyGObject	PyQt5库是Python与强大的GUI库——Qt的融合，它提供了Qt开发框架的Python接口，拥有超过300个类、将近6000个函数和方法，可开发功能强大的图形用户界面。WxPython 是跨平台库WxWidgets的Python版本，该库开源、支持跨平台，允许Python开发人员创建完整的、功能健全的图形用户界面，是一个优秀的GUI库。PyGObject绑定了Linux下最著名的图形库GTK3+，该库简单易用、功能强大、设计灵活，具有良好的设计理念和可扩展性，是一个优秀的GUI库。
机器学习	机器学习是一门涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科的多领域交叉学科，该学科旨在研究计算机如何模拟或实现人类的学习行为，以获取新的知识或技能、重新组织已有知识结构并不断改善自身。机器学习是人工智能的核心，是使计算机具有智能的根本途径。	Scikit-learn、TensorFlow、MXNet	Scikit-learn支持分类、回归、聚类、数据降维、模型选择、数据预处理，它提供了一批调用机器学习方法的接口，是Python机器学习领域中最优秀的免费库。TensorFlow 是一款以数据流图为基础，由谷歌人工智能团队开发和维护、免费且开源的机器学习计算框架，该框架支撑谷歌人工智能应用，提供了各类应用程序接口。MXNet是一个轻量级分布式可移植深度学习库，它支持多机多节点多GPU计算，提供可扩展的神经网络以及深度学习计算功能，可用于自动驾驶、语音识别等领域。
Web开发	Web开发指基于浏览器而非桌面进行的程序开发。	Django、Tornado、Flask、Twisted	Django 是一个免费开源且功能完善的Web框架，它采用MTV模式，提供URL路由映射、Request上下文和基于模板的页面渲染技术，内置一个功能强大的管理站点，适用于快速搭建企业级、高性能的内容类网站，是Python中最流行的Web开发框架。Tornado是一个高并发处理框架，它常被用作大型站点的接口服务框架，而非如Django般建立完整网站的框架。Tornado同样提供URL路由映射、Request上下文和基于模板的页面渲染技术，此外它还支持异步I/O、提供超时事件处理，内置了可直接用于生产环境的HTTP服务器。Flask是Python Web领域一个新兴框架，它吸收了其他框架的优点，功能简单，但具有可扩展性，一般用于实现小型网站的开发。Django、Tornado和Flask是基于应用层协议HTTP展开的框架，而Twisted是一个由事件驱动的网络框架。Twisted支持多种传输层和应用层协议，支持客户端和服务器双端开发，适用于开发追求服务器程序性能的应用。
网络应用开发	网络应用开发指以网络为基础的应用程序的开发	WeRoBot、aip、MyQR	WeRoBot库封装了很多微信公众号接口，提供了解析微信服务器消息及反馈消息的功能，该库简单易用，是建立微信机器人的重要技术手段。aip封装了百度AI开放平台接口，利用该库中封装的接口可快速开发各类网络应用，如天气预报、在线翻译、快递查询等等。MyQR是一个用于生成二维码的Python库。
游戏开发		PyGame、Panda3D	pygame 是为开发2D游戏而设计的Python第三方跨平台库，开发人员利用pygame中定义的接口，可以方便快捷地实现诸如图形用户界面创建、图形和图像的绘制、用户键盘和鼠标操作的监听以及播放音频等游戏中常用的功能panda3d是由迪士尼VR工作室和卡耐基梅隆娱乐技术中心开发的一个3D渲染和游戏开发库，该库强调能力、速度、完整性和容错能力，提供场景浏览器、性能监视器和动画优化工具，并通过完善代码来有效降低开发者跟踪和分析错误的难度
虚拟现实	图形艺术是一种通过标志来表现意义的艺术	Quads、ascii_art、turtle	Quads是一个基于四叉树和迭代操作的图形艺术库，其功能是以图像作为输入，将输入图像分为四个象限，根据输入图像中的颜色为每个象限分配平均颜色，误差最大的象限会被分成四个子象限以完善图像，以上过程重复N次。ascii_art是一种使用纯字符表示图像的技术，Python的ascii_art库提供了对该技术的支持，该库可对接收到的图片进行转换，以字符形式重构图片并输出。turtle 提供了绘制线、圆以及其他形状的函数，使用该库可以创建图形窗口，在图形窗口中通过简单重复动作直观地绘制界面与图形。
图像处理	图像处理一般指数字图像（数字图像是指用工业相机、摄像机和扫描仪等设备经过拍摄得到的一个大的二维数组，这个数组的元素称为像素，其值称为灰度值）处理，图像处理技术一般包括图像压缩、增强和复原、图像匹配、描述和识别。	Numpy、Scipy、Pillow、OpenCV-Python	数字图像的本质是数组，Numpy定义的数组类型非常适用于存储图像；Numpy提供基于数组的计算功能，利用这些功能可以很方便地修改图像的像素值。Scipy提供了对N维Numpy数组进行运算的函数，这些函数实现的功能，包括线性和非线性滤波、二值形态、B样条插值等都适用于图像处理。Pillow库是PIL库的一个分支，也是支持Python3的图像处理库，该库提供了对不同格式图像文件的打开和保存操作，也提供了包括点运算、色彩空间转换等基本的图像处理功能。OpenCV-Python 是OpenCV的Python版API，OpenCV是基于BSD许可发型的跨平台计算机视觉库，该库内部代码由C/C++编写，实现了图像处理和计算机视觉方面的很多通用算法；OpenCV-Python以Python代码对OpenCV进行封装，因此该库即方便使用又非常高效。

2. Python生态库的构建与发布

2.1 模块的构建与使用

库 是Python中常常提及的概念，但事实上Python中的库只是一种对特定功能集合的统一说法而非严格定义。

Python库的具体表现形式为 模块（Module）和 包（Package），下面分这两部分介绍Python库的构建与使用，并介绍如何发布第三方库。

Python模块本质上是一个包含Python代码片段的.py文件，模块名就是文件名。那么创建一个.py文件，在其中编写功能代码并保存，便可构建一个模块。

* 2.1.1第三方库/模块导入的格式

使用Python 进行编程时，有些功能没必要自己实现，可以借助Python 现有的标准库或其他人提供的第三方库。

• 方式一：import 模块名1, 模块名2 , ....

导入指定模块中的所有成员，使用该成员时需要加前缀

import math
impott turtle
math.pi
math.sin(0.5)
turtle.forward(100)

• 别名。 import math as m

import math as m	# 给模块设定别名，简短方便输入
m.pi
print(m.pi) # 3.141592653589793

• 方式二：from...import...

导入模块内指定的成员、模块属性（类），程序使用成员时无前缀。

from  math import pi
# from math import pi as p   # pi 别名 p 
print(pi)	# 输出 3.141592653589793

• from ... import *

导入模块中的所有成员，程序使用成员时无前缀。

from  math import *
print(pi)	# 3.141592653589793
print(sin(0.5))	# 0.479425538604203

---

构建模块 test.py

def add(a,b):
    return a+b
print(__name__)#Python文件作为脚本执行，模块名为__main__

#测试代码

#如何让module_demo只调用模块test，不执行测试代码？(避免导入模块中的测试代码)
if  __name__ =='__main__':#通过判断模块内置变量__name__
    result = add(1, 2)#函数调用
    print(result)

运行结果如下：

报 错："SyntaxError: cannot delete function call " 不能删除函数调用
原 因：test.py 函数代码关键字del 使用错误！！！

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()

使用模块：module_demo.py

import test
print(test.__name__)#test作为模块使用，打印模块名为test
result = test.add(11,22)#模块调用
print(result)

#当Python文件作为脚本文件或交互命令行当中执行时，它的模块名为__main__
#当Python文件作为模块使用时，它的模块名就是文件名

运行结果如下：

小 总 结：
#当Python文件作为脚本文件或在命令行当中执行时，它的模块名为 __main__
#当Python文件为模块使用时，它的模块名就是文件名

2.2 包的构建与导入

将模块放入一个文件夹，并在该文件夹中创建__init__.py文件，就构建了一个Python包。
简单地说，Python中的包就是以目录形式组织起来的、具有层级关系的多个模块。
Python包中可以包含子包，包结构示例如图所示。

此时若想在当前程序中导入以上包中的模块module_a，使用的导入语句如下：
import package.package_a.module_a # 方式一
from package.package_a import module_a #方式二

包的构建操作如下：

1、构建包package，鼠标选中项目名后右击 ，依次 选择 New - Directory 命名为package

2、新建package_a，鼠标选中package 右键，依次选中New - Python Package 后，弹出窗口中命名package_a。同理，新建package_b 和 module_b。
3、在package_a中新建module_a.py文件
注意：__ init __.py 文件是新建python package 文件时自动生成的。

包的导入操作：

在 package -package_a-module_a.py中

def test():
    print("hello world!")

在package-package_b-module_b.py中

import package.package_a.module_a
#from package.package_a import module_a
module_a.test()

效果如下:

2.3 库的发布

Python中的第三方库是由Python使用者自行编写与发布的模块或包，同样的，我们也可以将自己编写的模块与包作为库发布。具体步骤如下：

1.在与待发布的包 同级的目录中 创建setup.py文件。
2.编辑setup.py文件，在该文件中设置包中包含的模块。

from distutils.core import setup

setup(
    name='package',#包的名称
    version='1.0',#包的版本号
    description='我的Python包',#包的描述信息
    author='pyton',#包的作者
    #允许操作的python模块
    py_modules=['package.package_a.module_a','package.package_b.module_b']

)

3.在setup.py文件所在目录下打开Terminal命令行，使用python setup.py build命令构建Python库。

4.在setup.py文件所在目录下打开命令行，使用python setup.py sdist命令创建库的安装包。

如何安装库？

拷贝出创建库的压缩包，在桌面新建文件夹中解压

在文件夹中包含了package 和 seup.py文件

在当前文件页面按住 shift键 同时点击鼠标右键，选择 在此处打开powershell窗口。

在打开的界面中输入 ：python setup.py install

新建test_lib.py文件测试安装库

#import package.package_a.module_a
from package.package_a import module_a
module_a.test()

3.常用的内置Python库

3.1 time库

在开发程序的时候，有很多的场景会涉及到时间的处理，例如游戏中的防沉迷系统，如果我们在线时间太长，那么它就会给我们一个提示信息或是强制下线。那么，如何使用Python模拟这一功能呢？

time是最基础的时间处理库，该库本质上是一个模块，它包含的所有内容都定义在time.py文件中。该库中定义了time()、strftime()、localtime()、sleep()和一些用于实现时间格式转换的函数。

下面针对这些函数进行详细介绍：

time()函数:

作用： time() 函数返回以 浮点数 表示的从世界标准时间的 1970年1月1日00:00:00 开始到现在的总秒数，也就是 时间戳 。

import time
# time():返回一个浮点数类型的时间戳
print(time.time())

浮点数展现出来的时间戳，不便于阅读，并且过于抽象。

因此，Python提供了结构化的函数，localtime()与gmtime()函数。

localtime() 函数和 gmtime() 函数都可将时间戳转换为以元组表示的时间对象（struct_time），localtime() 得到的是当地时间，gmtime()得到的是世界统一时间（Coordinated Universal Time，简称UTC），它们的语法格式如下：

• localtime([secs])
• gmtime([secs])

参数secs是一个表示时间戳的浮点数，若不提供该参数，默认以 time() 函数获取的时间戳作为参数。

localtime()与gmtime()函数的使用方法：

import time
# time():返回一个浮点数类型的时间戳
#print(time.time())

#1630042690.2986755
#localtime：将时间戳转换为时间对象，当地时间
#gmtime：将时间戳转换为时间对象，世界时间  UTC  北京时间=utc + 8

print(time.localtime(1630042690.2986755
))
print(time.gmtime(1630042690.2986755
))

输出结果如下 ：

time.struct_time(tm_year=2021, tm_mon=8, tm_mday=27, tm_hour=13, tm_min=38, tm_sec=10, tm_wday=4, tm_yday=239, tm_isdst=0)

time.struct_time(tm_year=2021, tm_mon=8, tm_mday=27, tm_hour=5, tm_min=38, tm_sec=10, tm_wday=4, tm_yday=239, tm_isdst=0)

从输出的结果可以看出，这 两个函数 主要返回的 时间对象 time.struct_time ,在时间对象中分为 9 项元素。

time.struct 元组元素的含义与取值：

元素	含义	取值
tm_year	年	4位数字
tm_mon	月	1~12
tm_mday	日	1~31
tm_hour	时	0~23
tm_min	分	0~59
tm_sec	秒	0~61（60或61是闰秒）
tm_wday	一周的第几日	0~6(0为周一，以此类推)
tm_yday	一年的第几日	1~366
tm_isdst	夏令时	1:是夏令时， 0：非夏令时 ，-1：不确定

strftime()和asctime()函数:

strftime() 函数 借助时间格式控制符来输出格式化的时间字符串，该函数的 语法格式 如下：

• strftime(format[, t])

参数format是指代时间格式的字符串。
参数 t 为 struct_time 对象，默认为当前时间，即localtime()函数返回的时间，该参数可以省略。

参数 forrmat 时间格式控制符

时间格式控制符	说明
%Y	四位数的年份，取值范围0001~9999
%m	月份（01~12）
%d	月中的第一天
%B	本地完整的月份名称，比如january
%b	本地简化的月份，比如 Jan
%a	本地简化的周日期
%A	本地完整的周日期
%H	24小时制小时数（0~23）
%I	12小时制小时数（01~12）
%p	上下午，AP或者PM
%M	分钟数（00~59）
%S	秒（00~59）

在PyCharm中测试如下：

import time
# time():返回一个浮点数类型的时间戳
#print(time.time())

#1630042690.2986755
#localtime：将时间戳转换为时间对象，当地时间
#gmtime：将时间戳转换为时间对象，世界时间  UTC  北京时间=utc + 8

print(time.localtime(1630042690.2986755
))
print(time.gmtime(1630042690.2986755
))
# strftime (format,[t]) 将时间对象格式化为时间字符串

print(time.strftime('%H:%M:%S',time.localtime()))

从输出结果可以看出，输出的时间字符串更加便于人们阅读。

asctime()函数同样用于输出格式化的时间字符串，但它只将struct_time 时间对象转化为时间字符串Sat Jan 13 21:56:34 2018'这种形式。asctime()函数的语法格式如下：

• asctime([t])

以上格式中的参数t与和 strftime() 函数的参数 t 意义相同。

接下来在Pycharm中演示 asctime() 函数的使用：

import time
# time():返回一个浮点数类型的时间戳
#print(time.time())

#1630042690.2986755
#localtime：将时间戳转换为时间对象，当地时间
#gmtime：将时间戳转换为时间对象，世界时间  UTC  北京时间=utc + 8

print(time.localtime(1630042690.2986755
))
print(time.gmtime(1630042690.2986755
))
# strftime (format,[t]) 将事件对象格式化为时间字符串

print(time.strftime('%H:%M:%S',time.localtime()))

#asctime([t]) :将时间对象格式化为时间字符串  星期 x月 x日  时 分 秒 年份

print(time.asctime(time.localtime()))

输出结果如下：

ctime()函数

ctime() 函数用于将一个时间戳（以秒为单位的浮点数）转换为 Sat Jan 13 21:56:34 2018 这种形式（结果同time.asctime()），若该函数未接收到参数，则默认以time.time()作为参数。

在PyCharm中演示，ctime()函数的使用：

import time
# time():返回一个浮点数类型的时间戳
#print(time.time())

#1630042690.2986755
#localtime：将时间戳转换为时间对象，当地时间
#gmtime：将时间戳转换为时间对象，世界时间  UTC  北京时间=utc + 8

print(time.localtime(1630042690.2986755
))
print(time.gmtime(1630042690.2986755
))
# strftime (format,[t]) 将事件对象格式化为时间字符串

print(time.strftime('%H:%M:%S',time.localtime()))

#asctime([t]) :将时间对象格式化为时间字符串 格式为： 星期 x月 x日  时 分 秒 年份

print(time.asctime(time.localtime()))

#ctime([secs]):将时间戳格式化为时间字符串 格式为：星期 x月 x日  时 分 秒 年份
print(time.ctime())

输出结果如下：

strptime() 函数

strptime()函数用于将格式化的时间字符串转化为时间对象struct_time，该函数是strftime()函数的反向操作。strptime()函数的语法格式如下：

• strptime(string, format)

以上格式中的参数 string 表示格式化的时间字符串，format表示时间字符串的格式，string与format必须统一。

在PyCharm中演示，strptime()函数的使用：

import time
# time():返回一个浮点数类型的时间戳
#print(time.time())

#1630042690.2986755
#localtime：将时间戳转换为时间对象，当地时间
#gmtime：将时间戳转换为时间对象，世界时间  UTC  北京时间=utc + 8

print(time.localtime(1630042690.2986755))
print(time.gmtime(1630042690.2986755))
# strftime (format,[t]) 将事件对象格式化为时间字符串

print(time.strftime('%H:%M:%S',time.localtime()))

#asctime([t]) :将时间对象格式化为时间字符串 格式为： 星期 x月 x日  时 分 秒 年份

print(time.asctime(time.localtime()))

#ctime([secs]):将时间戳格式化为时间字符串 格式为：星期 x月 x日  时 分 秒 年份
print(time.ctime())

#strptime(string,format):将时间字符串转换成时间对象
print(time.strptime('11:22:33','%H:%M:%S'))

sleep()函数

sleep()函数可让调用该函数的程序进入睡眠态，即让其暂时挂起，等待一定时间后再继续执行。sleep() 函数接收一个以秒为单位的浮点数作为参数，使用该参数控制进程或线程挂起的时长。

• time.sleep(1) #延时1秒

时间计算 通常指时间的加减，时间可以时间戳形式进行加减运算。若要对非时间戳形式表示的时间进行计算，在计算之前可以先将其转换为时间戳形式。各形式之间的转换方式如图所示。

mktime 函数

将时间对象转换成时间戳

import time
#定义变量t为延时1秒
t = 1
# time():返回一个浮点数类型的 时间戳
#print(time.time())
#1630042690.2986755

#localtime：将时间戳转换为时间对象，当地时间
#gmtime：将时间戳转换为时间对象，世界时间  UTC  北京时间=utc + 8
print(time.localtime(1630042690.2986755))
print(time.gmtime(1630042690.2986755))

# strftime (format,[t]) 将事件对象格式化为时间字符串
print(time.strftime('%H:%M:%S',time.localtime()))

#asctime([t]) :将时间对象格式化为时间字符串 格式为： 星期 x月 x日  时 分 秒 年份
print(time.asctime(time.localtime()))

#ctime([secs]):将时间戳格式化为时间字符串 格式为：星期 x月 x日  时 分 秒 年份
print(time.ctime())

#mktime：将时间对象转换成时间戳
print(time.mktime(time.localtime()))

#strptime(string,format):将时间字符串转换成时间对象
print(time.strptime('11:22:33','%H:%M:%S'))


# sleep() ：让程序进入睡眠状态
time.sleep(t)

3.2 random 库

random 是Python内置的标准库，在程序中导入该库，可利用库中的函数生成随机数据。random库中常用的函数如表所示。

在PyCharm中演示代码如下：

import random

#生成0~1随机浮点数
print(random.random()) #只能0~1
print(random.uniform(0,1)) #可指定范围

#生成指定范围的随机整数
print(random.randint(2,8))
print(random.randrange(2,8,1)) #1为步长

ls = ['c','python','java','php']  # 列表中包含了4个元素
print(random.choice(ls)) #随机输出列表中的一个元素

random.shuffle(ls)#将序列中的元素重新排列
print(ls)

print(random.sample(ls,3)) #在ls序列中随机获取3个元素，组成新的序列并重新排序

#

输出结果如下：

3.3 turtle 库

turtle（海龟）是Python内置的一个标准模块，它提供了绘制线、圆以及其它形状的函数，使用该模块可以创建图形窗口，在图形窗口中通过简单重复动作直观地绘制界面与图形。

turtle的使用主要分为以下三个方面：

• 创建窗口
• 设置画布
• 绘制图形

1、创建窗口

图形窗口也称为画布（canas）。

控制台无法绘制图形，使用turtle模块绘制图形化界面，需要先使用setup()函数创建图形窗口。语法格式如下：

• turtle.setup(width, height, startx=None, starty=None)

在PyCharm中演示代码的使用

建一个宽度为800像素，高度为600像素，并且位于屏幕中心

import  turtle

#创建一个宽度为800像素，高度为600像素，并且位于屏幕中心
turtle.setup(800,600)

turtle.done() # 防止窗口一闪而过

效果如下：

2、设置画布

画笔（pen）的设置包括画笔属性，如尺寸、颜色的设置，和画笔状态的设置。

（1）画笔属性函数

• turtle.pensize(<width>)# 设置画笔尺寸
• turtle.speed(speed) # 设置画笔移动速度
• turtle.color(color) # 设置画笔颜色

参数含义：

• pensize()函数的参数width可以设置画笔绘制出的线条的宽度。
• speed()函数的参数speed用于设置画笔移动的速度。
• color()函数的参数color用于设置画笔的颜色。

（2）画笔状态函数

• turtle.penup() # 提起画笔
• turtle.pendown() # 放下画笔

说明：

• turtle模块中为penup()和pendown()函数定义了别名;
• penup()函数的别名为pu();
• pendown()函数的别名为pd()。

3、绘制图形

在画笔状态为DOWN时，通过移动画笔可以在画布上绘制图形，可以将画笔想象成一只海龟（这也是turtle模块名字的由来）：海龟落在画布上，它可以向前、向后、向左、向右移动，海龟爬动时在画布上留下痕迹，路径即为所绘图形。

(1)移动控制函数

turtle.forward(distance) # 向前移动
turtle.backward(distance) # 向后移动
turtle.goto(x,y=None) # 移动到指定位置

参数含义：

• 函数forward()和backward()的参数distance用于指定画笔移动的距离，单位为像素；
• 函数goto()用于将画笔移动到画布上指定的位置，该函数可以使用x、y分别接收表示目标位置的横坐标和纵坐标，也可以仅接收一个表示坐标向量的参数。

(2)角度控制函数

• turtle.right(degree) # 向右转动
• turtle.left(degree) # 向左转动
• turtle.seth(angle) # 转动到某个方向

参数含义：

• 函数right()和left()的参数degree用于指定画笔向右与向左的角度；
• 函数seth()的参数angle用于设置画笔在坐标系中的角度。

(3) 绘制函数

turtle.circle(radius, extent=None, steps=None)

(4) 图形填充

• turtle.begin_fill() # 开始填充
• turtle.end_fill() # 结束填充

4. 实训案例

4.1 图形绘制

import turtle
# 三角形
turtle.pensize(3)
# 抬起画笔
turtle.penup()
# 移动到指定位置
turtle.goto(-200, -50)
# 放下画笔
turtle.pendown()
# 开始填充
turtle.begin_fill()
# 填充颜色
turtle.color('red')
# 半径为40
turtle.circle(40, steps=3)
# 填充结束
turtle.end_fill()
# 正方形
turtle.penup()
turtle.goto(-100, -50)
turtle.pendown()
turtle.begin_fill()
turtle.color('blue')
turtle.circle(40, steps=4)
turtle.end_fill()
# 五边形
turtle.penup()
turtle.goto((0, -50))
turtle.pendown()
#
turtle.begin_fill()
turtle.color('yellow')
turtle.circle(40, steps=5)
turtle.end_fill()
# 六边形
turtle.penup()
turtle.goto(100, -50)
turtle.pendown()
turtle.begin_fill()
turtle.color('seashell')
turtle.circle(40, steps=6)
turtle.end_fill()
# 圆形
turtle.penup()
turtle.goto(200, -50)
turtle.pendown()
turtle.begin_fill()
turtle.color('purple')
turtle.circle(40)
turtle.end_fill()
# 文字
turtle.color('green')
turtle.penup()
turtle.goto(-100, 50)
turtle.pendown()
turtle.write("Cool Colorful Shapes", font=("Times", 18, "bold"))
# 可见性，隐藏海龟，也就是海龟画笔
turtle.hideturtle()
turtle.done()

4.2 模拟时钟

from turtle import *
from datetime import *

def skip(step):
    '''
    跳跃给定的距离
    '''
    penup()
    forward(step)
    pendown()


def setup_clock(radius):
    '''
    建立钟表的外框
    '''
    reset()
    pensize(7)   	 	# 设置画笔线条的粗细
    for i in range(60):
        skip(radius)  	# 在距离圆心为r的位置落笔
        if i % 5 == 0:  # 若能整除5，则画一条短直线
            forward(20)
            skip(- radius - 20)
        else:          	# 否则画点
            dot(5)
            skip(-radius)
        right(6)


def make_hand(name, length):
    '''
    注册turtle形状，建立名字为name的形状
    '''
    reset()
    skip(-0.1 * length)
    # 开始记录多边形的顶点
    begin_poly()
    forward(1.1 * length)
    # 停止记录多边形的顶点,并与第一个顶点相连
    end_poly()
    # 返回最后记录的多边形
    handForm=get_poly()
    # 注册形状，命名为name
    register_shape(name, handForm)


def init():
    global secHand, minHand, hurHand, printer
    # 重置turtle指针向北
    mode("logo")
    # 建立3个表示表针的Turtle对象并初始化
    secHand = Turtle()
    make_hand("secHand", 130)   # 秒针
    secHand.shape("secHand")
    minHand = Turtle()
    make_hand("minHand", 125)   # 分针
    minHand.shape("minHand")
    hurHand = Turtle()
    make_hand("hurHand", 90)    # 时针
    hurHand.shape("hurHand")
    for hand in secHand, minHand, hurHand:
        hand.shapesize(1, 1, 3)     # 调整3根指针的粗细
        hand.speed(0)             	# 设置移动速度
    # 建立并输出文字的Turtle对象
    printer = Turtle()
    printer.hideturtle()
    printer.penup()


def week(t):
    week=["星期一","星期二","星期三","星期四","星期五","星期六","星期七"]
    return week[t.weekday()]


def day(t):
    return "%s %d %d" %(t.year,t.month,t.day)


def tick():
    '''
    绘制钟表的动态显示
    '''
    t = datetime.today()           # 获取本地当前的日期与时间
    # 处理时间的秒数、分钟数、小时数
    second = t.second + t.microsecond * 0.000001
    minute = t.minute + t.second / 60.0
    hour = t.hour + t.minute / 60.0
    # 将secHand 、minHand 和hurHand 的方向设为指定的角度
    secHand.setheading(second * 6)
    minHand.setheading(minute * 6)
    hurHand.setheading(hour * 30)
    tracer(False)
    printer.fd(70)                  # 向前移动指定的距离
    # 根据 align（对齐方式）和font（字体)，在当前位置写入文本
    printer.write(week(t),align="center",font=("Courier", 14, "bold"))
    printer.back(130)
    printer.write(day(t),align="center",font=("Courier", 14, "bold"))
    # 调用 home() 方法将位置和方向恢复到初始状态, 位置的初始坐标为（0,0 ）,
    # 初始方向有两种情况：若为"standard" 模式，则初始方向为right ，表示朝向东；
    # 若为 "logo" 模式，则初始方向是up，表示朝向北
    printer.home()
    tracer(True)
    # 设置计时器，100ms 后继续调用 tick() 函数
    ontimer(tick,100)


def main():
    # 关闭绘画追踪，可以用于加速绘画复杂图形
    tracer(False)
    init()
    # 画表框
    setup_clock(200)
    # 开启动画
    tracer(True)
    tick()
	# 启动事件循环,开始接收鼠标的和键盘的操作
    done()


main()

4.3 双人乒乓球小游戏

# Simple Pong in Python 3 for Beginners

import turtle
import os
import time

wn = turtle.Screen()
wn.title("Pong")
wn.bgcolor("black")
wn.setup(width=800, height=600)
wn.tracer(0)

# Score
score_a = 0
score_b = 0

# Paddle A
paddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5, stretch_len=1)
paddle_a.penup()
paddle_a.goto(-350, 0)

# Paddle B
paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5, stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0)

# Ball
ball = turtle.Turtle()
ball.speed(0)
ball.shape("square")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 1
ball.dy = 1

# Pen
pen = turtle.Turtle()
pen.speed(0)
pen.shape("square")
pen.color("white")
pen.penup()
pen.hideturtle()
pen.goto(0, 260)
pen.write("Player A: 0  Player B: 0", align="center", font=("Courier", 24, "normal"))


# Functions
def paddle_a_up():
    y = paddle_a.ycor()
    y += 40
    paddle_a.sety(y)


def paddle_a_down():
    y = paddle_a.ycor()
    y -= 40
    paddle_a.sety(y)


def paddle_b_up():
    y = paddle_b.ycor()
    y += 40
    paddle_b.sety(y)


def paddle_b_down():
    y = paddle_b.ycor()
    y -= 40
    paddle_b.sety(y)


# Keyboard bindings
wn.listen()
wn.onkeypress(paddle_a_up, "w")
wn.onkeypress(paddle_a_down, "s")
wn.onkeypress(paddle_b_up, "Up")
wn.onkeypress(paddle_b_down, "Down")

# Main game loop
while True:
    wn.update()

    # Move the ball
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)
    time.sleep(0.01)

    # Border checking

    # Top and bottom
    if ball.ycor() > 290:
        ball.sety(290)
        ball.dy *= -1
        os.system("afplay bounce.wav&")

    elif ball.ycor() < -290:
        ball.sety(-290)
        ball.dy *= -1
        os.system("afplay bounce.wav&")

    # Left and right
    if ball.xcor() > 350:
        score_a += 1
        pen.clear()
        pen.write("Player A: {}  Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))
        ball.goto(0, 0)
        ball.dx *= -1

    elif ball.xcor() < -350:
        score_b += 1
        pen.clear()
        pen.write("Player A: {}  Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))
        ball.goto(0, 0)
        ball.dx *= -1

    # Paddle and ball collisions
    if ball.xcor() < -340 and ball.ycor() < paddle_a.ycor() + 50 and ball.ycor() > paddle_a.ycor() - 50:
        ball.dx *= -1
        os.system("afplay bounce.wav&")

    elif ball.xcor() > 340 and ball.ycor() < paddle_b.ycor() + 50 and ball.ycor() > paddle_b.ycor() - 50:
        ball.dx *= -1
        os.system("afplay bounce.wav&")

4.4 贪吃蛇小游戏

# 导入turtle库，制作snake，food动画
from turtle import *
# 导入random库，让food随机出现
from random import randrange
# 导入freegam库，库中封装了许多元素，用正方形表示food，用vector二维向量表示snake的移动
from freegames import square, vector

# 初始化food，snake 的坐标
food = vector(0, 0)
snake = [vector(10, 0)]
# vector（1，-10） 表示第一个food 的位置以snake的头为原点，x坐标为0，y坐标为-10
aim = vector(0, -10)

# 改变方向
def change(x, y):
    "Change snake direction.改变蛇的方向"
    aim.x = x
    aim.y = y

# 判断是否碰壁
def inside(head):
    "Return True if head inside boundaries.如果头部在边界内，则返回 True。"
    return -200 < head.x < 190 and -200 < head.y < 190


def move():
    "Move snake forward one segment.将蛇向前移动一段。"
    head = snake[-1].copy()
    head.move(aim)

    if not inside(head) or head in snake:  # 结束游戏 碰壁、头碰到身体
        square(head.x, head.y, 9, 'red')
        update()
        return

    snake.append(head)
    # snake吃到food ，下一个food随机出现
    if head == food:
        print('Snake:', len(snake))
        food.x = randrange(-15, 15) * 10
        food.y = randrange(-15, 15) * 10
    # snake没有吃到food，snake列表pop（0）
    else:
        snake.pop(0)

    clear()

    for body in snake:
        square(body.x, body.y, 9, 'green')

    square(food.x, food.y, 9, 'red')
    update()
    ontimer(move, 100)

# 创建初始画布尺寸

# setup(420, 420, 370, 0)

# 隐藏鼠标
hideturtle()
tracer(False)

# 监听
listen()

# 绑定键盘方向
onkey(lambda: change(10, 0), 'Right')               # 键盘 右→键
onkey(lambda: change(-10, 0), 'Left')               # 键盘 左←键    x 坐标减 -10
onkey(lambda: change(0, 10), 'Up')                  # 键盘 上↑键
onkey(lambda: change(0, -10), 'Down')               # 键盘 下↓键    y 坐标减 -10
move()          # 调用move()移动函数
done()          # 暂停程序，停止画笔绘制，但绘图窗体不关闭

5. 常用的第三方Python库

5.1 jieba库

5.2 wordcloud 库

5.3 pygame 库

5.3.1 pygame库-pygame的初始化和退出

5.3.2 pygame库-创建游戏窗口

5.3.3 pygame库-游戏循环与游戏时钟

5.3.4 pygame库-图形和文本绘制

5.3.5 pygame库-元素位置 控制

5.3.6 pygame库-动态效果

5.3.7pygame库-事件与事件处理

6. 实训案例

6.1 出场人物统计

import jieba
# 打开并读取“西游记.txt”
txt = open(r"西游记.txt", "rb").read()
# 构建排除词库
excludes = {"一个", "那里", "怎么", "我们", "不知", "两个", "甚么",
              "只见", "不是","原来", "不敢", "闻言", "如何", "什么"}
# 使用jieba分词
words = jieba.lcut(txt)
# 对划分的单词计数
counts = {}
for word in words:
    if len(word) == 1:
        continue
    elif word == "行者" or word == "大圣" or word == "老孙":
        rword = "悟空"
    elif word == "师父" or word == "三藏" or word == "长老":
        rword = "唐僧"
    elif 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(9):
    word, count = items[i]
    print("{0:<5}{1:>5}次".format(word, count))

6.2 小猴子接香蕉

import random
from sys import exit
import pygame
from pygame.locals import *

pygame.init()
# 屏幕宽度
screen_width = 450
# 屏幕高度
screen_height = 560
# 绘制窗口
screen = pygame.display.set_mode((screen_width, screen_height), 0, 32)

# 游戏标题
pygame.display.set_caption("猴子接桃")
# 分数字体，字号
run_time_font = pygame.font.SysFont('simhei', 48)


def game_start():
    # 加载图片
    '''注意：1.图片文件放在.py文件同一目录只需monkey.png;    2.图片文件的路径'''
    #monkey = pygame.image.load('monkey.png')
    monkey = pygame.image.load('./image/monkey.png')
    banana = pygame.image.load('./image/banana.png')
    game_background = pygame.image.load('./image/background.jpg')
    # 香蕉下落速度
    speed = 1
    # 分数
    score = 0
    # 猴子位置信息
    monkey_x = 200
    monkey_y = 470
    # 设置移动速度
    monkey_x_speed = 1
    monkey_move = {K_LEFT: 0, K_RIGHT: 0}
    # 香蕉坐标列表
    pos_list = []
    # 绘制初始化香蕉
    for i in range(7):
        x = random.randint(0, 390)
        y = random.randint(0, 560)
        pos_list.append([x, y])
    # 帧率控制Clock对象
    clock = pygame.time.Clock()
    while True:
        screen.blit(game_background, (0, 0))
        # 接收信息处理
        for event in pygame.event.get():
            if event.type == QUIT:
                exit()
            if event.type == KEYDOWN:
                if event.key in monkey_move:
                    monkey_move[event.key] = 1
            elif event.type == KEYUP:
                if event.key in monkey_move:
                    monkey_move[event.key] = 0
        second_time_passed = clock.tick(60)
        # 定位猴子移动后坐标
        monkey_x -= monkey_move[K_LEFT] * monkey_x_speed * second_time_passed
        monkey_x += monkey_move[K_RIGHT] * monkey_x_speed * second_time_passed
        # 判断猴子边界条件
        if monkey_x > 450 - monkey.get_width():
            monkey_x = 450 - monkey.get_width()
        elif monkey_x < 0:
            monkey_x = 0
        screen.blit(monkey, (monkey_x, monkey_y))
        for y in pos_list:  # 坐标循环，从y轴垂直下落
            y[1] = y[1] + speed
            screen.blit(banana, (y[0], y[1]))  # 绘制香蕉
            if y[1] >= 560:
                y[1] = -banana.get_height()
            # 碰撞检测
            if monkey_x < y[0] < monkey_x + monkey.get_width() and monkey_y - banana.get_height() < y[1] < monkey_y:
                score += 10
                pos_list.remove([y[0], y[1]])
                x, y = random.randint(0, 390), random.randint(0, 560)
                if len(pos_list) <= 6:
                    pos_list.append([x, -y])
        screen_score = run_time_font.render('分数：' + str(score), True, (255, 0, 0))
        screen.blit(screen_score, (0, 0))
        # 刷新显示
        pygame.display.update()


if __name__ == '__main__':
    while True:
        game_start()

---

划重点
1、本人在CSDN论坛写的所有文章，仅针对本人自身做学习记录，不全面，不详细，还请见谅！

如果有小伙伴需要详细解答或完整的学习资源（含视频教程）, 欢迎加入我的知识星球「Naiva的知识问答社区」

2、《Python快速入门》配套视频、源代码、习题、教学课件等资源8G学习资料百度网盘下载链接>>点击这里 << ，获取密码>>点击这里<<。