├── .gitignore ├── README.md ├── cover-1.jpg ├── cover-2.jpg ├── cover-3.jpg ├── float_repr_1.png ├── float_repr_2.png ├── res ├── day01 │ ├── github_pypl_and_ieee_spectrum.png │ ├── install_python_1.png │ ├── install_python_2.png │ ├── install_python_3.png │ ├── install_python_4.png │ ├── install_python_5.png │ ├── install_python_6.png │ ├── install_python_7.png │ ├── python_download_page_1.png │ ├── python_download_page_2.png │ ├── tiobe_index.png │ ├── vs_build_tools_download.png │ └── vs_build_tools_install.png ├── day02 │ ├── pycharm_download_page.png │ ├── using_pycharm_1.png │ ├── using_pycharm_2.png │ ├── using_pycharm_3.png │ ├── using_pycharm_4.png │ ├── using_pycharm_5.png │ ├── using_pycharm_6.png │ ├── using_pycharm_7.png │ ├── using_pycharm_8.png │ └── visual_studio_code.png ├── day06 │ └── terminate_program.png ├── day09 │ ├── lottery.png │ └── lottery_run_result.png ├── day11 │ └── ENIAC.jpg ├── day12 │ └── set_operations.png ├── day13 │ └── xinhua_dictionary.jpg ├── day14 │ └── function_definition.png ├── day18 │ ├── 20210731182741.png │ └── 20210731182914.png └── qrcode.JPG ├── 第01课：初识Python.md ├── 第02课：第一个Python程序.md ├── 第03课：Python语言中的变量.md ├── 第04课：Python语言中的运算符.md ├── 第05课：分支结构.md ├── 第06课：循环结构.md ├── 第07课：分支和循环结构的应用.md ├── 第08课：常用数据结构之列表-1.md ├── 第09课：常用数据结构之列表-2.md ├── 第10课：常用数据结构之元组.md ├── 第11课：常用数据结构之字符串.md ├── 第12课：常用数据结构之集合.md ├── 第13课：常用数据结构之字典.md ├── 第14课：函数和模块.md ├── 第15课：函数的应用.md ├── 第16课：函数使用进阶.md ├── 第17课：函数高级应用.md ├── 第18课：面向对象编程入门.md ├── 第19课：面向对象编程进阶.md └── 第20课：面向对象编程应用.md /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | cover_1.png 3 | cover_2.png 4 | cover-1.jpg 5 | cover-2.jpg 6 | cover-3.jpg 7 | 8 | old 9 | video 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## 从零开始学Python（2023版） 2 | 3 | 自2020年3月在知乎上创建“从零开始学Python”专栏以来，收到了很多小伙伴的点赞、收藏、评论、私信。后面，我们把这套教程做成了开源项目[《*Python-Core-50-Courses*》](https://github.com/jackfrued/Python-Core-50-Courses)。如今三年时间过去了，Python 语言、开发工具以及 Python 的生态圈都或多或少的发生了变化，是时候制作一套新版本的教程了！ 4 | 5 | 本次新版本的制作主要目标有以下几点： 6 | 7 | 1. 力求语言更加精炼和准确，减少初学者上手的难度。 8 | 2. 加强与读者的互动，及时处理 issue 和 pull request。 9 | 3. 覆盖 Python 3.8到 Python 3.10的主要新特性。 10 | 4. 侧重 Python 语言在自动化和数据科学领域的应用。 11 | 5. 在适当的地方增加对 Python 和数据科学面试题的讲解。 12 | 6. 为每篇文章提供配套的视频讲解。 13 | 14 | 文档配套的视频放在了B站和抖音，欢迎大家关注我的B站和抖音，刚刚起号希望大家多多关注、点赞和评论，不胜感激。 15 | 16 | 17 | 18 | 最后，感谢大家关注和 star 这个仓库，愿你我都是“出走半生，归来仍是少年”！ 19 | 20 | > **说明**：文档中包含了数学公式，默认情况下，GitHub 上的 markdown 文档无法渲染数学公式。对于使用 Chrome 浏览器的用户，如果希望正确显示这些数学公式，可以打开 Chrome 应用商店，搜索名为 MathJax Plugin for Github 的插件并安装它。启用该插件后，GitHub 上面 markdown 文档中的数学公式就可以正常显示了。 21 | -------------------------------------------------------------------------------- /cover-1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/cover-1.jpg -------------------------------------------------------------------------------- /cover-2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/cover-2.jpg -------------------------------------------------------------------------------- /cover-3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/cover-3.jpg -------------------------------------------------------------------------------- /float_repr_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/float_repr_1.png -------------------------------------------------------------------------------- /float_repr_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/float_repr_2.png -------------------------------------------------------------------------------- /res/day01/github_pypl_and_ieee_spectrum.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/github_pypl_and_ieee_spectrum.png -------------------------------------------------------------------------------- /res/day01/install_python_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_1.png -------------------------------------------------------------------------------- /res/day01/install_python_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_2.png -------------------------------------------------------------------------------- /res/day01/install_python_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_3.png -------------------------------------------------------------------------------- /res/day01/install_python_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_4.png -------------------------------------------------------------------------------- /res/day01/install_python_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_5.png -------------------------------------------------------------------------------- /res/day01/install_python_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_6.png -------------------------------------------------------------------------------- /res/day01/install_python_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/install_python_7.png -------------------------------------------------------------------------------- /res/day01/python_download_page_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/python_download_page_1.png -------------------------------------------------------------------------------- /res/day01/python_download_page_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/python_download_page_2.png -------------------------------------------------------------------------------- /res/day01/tiobe_index.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/tiobe_index.png -------------------------------------------------------------------------------- /res/day01/vs_build_tools_download.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/vs_build_tools_download.png -------------------------------------------------------------------------------- /res/day01/vs_build_tools_install.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day01/vs_build_tools_install.png -------------------------------------------------------------------------------- /res/day02/pycharm_download_page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/pycharm_download_page.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_1.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_2.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_3.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_4.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_5.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_6.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_7.png -------------------------------------------------------------------------------- /res/day02/using_pycharm_8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/using_pycharm_8.png -------------------------------------------------------------------------------- /res/day02/visual_studio_code.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day02/visual_studio_code.png -------------------------------------------------------------------------------- /res/day06/terminate_program.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day06/terminate_program.png -------------------------------------------------------------------------------- /res/day09/lottery.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day09/lottery.png -------------------------------------------------------------------------------- /res/day09/lottery_run_result.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day09/lottery_run_result.png -------------------------------------------------------------------------------- /res/day11/ENIAC.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day11/ENIAC.jpg -------------------------------------------------------------------------------- /res/day12/set_operations.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day12/set_operations.png -------------------------------------------------------------------------------- /res/day13/xinhua_dictionary.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day13/xinhua_dictionary.jpg -------------------------------------------------------------------------------- /res/day14/function_definition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day14/function_definition.png -------------------------------------------------------------------------------- /res/day18/20210731182741.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day18/20210731182741.png -------------------------------------------------------------------------------- /res/day18/20210731182914.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/day18/20210731182914.png -------------------------------------------------------------------------------- /res/qrcode.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jackfrued/Python-for-Freshmen-2023/5c62fb1cf628762be9b65f5b35f23c8bf2db59a4/res/qrcode.JPG -------------------------------------------------------------------------------- /第01课：初识Python.md: -------------------------------------------------------------------------------- 1 | ## 第01课：初识Python 2 | 3 | ### Python简介 4 | 5 | Python（英式发音：/ˈpaɪθən/；美式发音：/ˈpaɪθɑːn/）是由荷兰人吉多·范罗苏姆（Guido von Rossum）发明的一种编程语言，是目前世界上最受欢迎和拥有最多用户群体的编程语言。Python 强调代码的可读性和语法的简洁性，相较于 C 或 Java，Python 让使用者能够用更少的代码表达自己的意图。下面是几个权威的编程语言排行榜给出的 Python 语言的排名，其中第1张图由 TIOBE Index 提供，第3张图由 IEEE Spectrum 提供。值得一提的是第2张图，它展示了编程语言在全球最大代码托管平台 GitHub 上受欢迎的程度，最近的四年时间 Python 语言都处于冠军的位置。 6 | 7 | 8 | 9 | 10 | 11 | #### Python的编年史 12 | 13 | 1. 1989年12月：吉多·范罗苏姆决心开发一个新的脚本语言及其解释器来打发无聊的圣诞节。这种语言将作为 ABC 语言的继承者，主要用来替代 Unix shell 和 C 语言实现系统管理。由于吉多本人是 BBC 电视剧《*Monty Python's Flying Circus*》的忠实粉丝，所以他选择了 Python 这个词作为新语言的名字。 14 | 2. 1991年02月：吉多·范罗苏姆在 alt.sources 新闻组上发布了 Python 解释器的最初代码，标记为版本0.9.0。 15 | 3. 1994年01月：Python 1.0发布，梦开始的地方。 16 | 4. 2000年10月：Python 2.0发布，Python 的整个开发过程更加透明，生态圈开始慢慢形成。 17 | 5. 2008年12月：Python 3.0发布，引入了诸多现代编程语言的新特性，但并不完全向下兼容。 18 | 6. 2011年04月：pip 首次发布，Python 语言有了自己的包管理工具。 19 | 7. 2018年07月：吉多·范罗苏姆宣布从“终身仁慈独裁者”（开源项目社区出现争议时拥有最终决定权的人）的职位上“永久休假”。 20 | 8. 2020年01月：在 Python 2和 Python 3共存了11年之后，官方停止了对 Python 2的更新和维护，希望用户尽快切换到 Python 3。 21 | 22 | > **说明**：大多数软件的版本号一般分为三段，形如A.B.C，其中A表示大版本号，当软件整体重写升级或出现不向后兼容的改变时，才会增加A；B表示功能更新，出现新功能时增加B；C表示小的改动（例如：修复了某个Bug），只要有修改就增加C。 23 | 24 | #### Python的优缺点 25 | 26 | Python 语言的优点很多，简单为大家列出几点。 27 | 28 | 1. **简单优雅**，跟其他很多编程语言相比，Python **更容易上手**。 29 | 2. 能用更少的代码做更多的事情，**提升开发效率**。 30 | 3. 开放源代码，拥有**强大的社区和生态圈**。 31 | 4. **能够做的事情非常多**，有极强的适应性。 32 | 5. **胶水语言**，能够黏合其他语言开发的东西。 33 | 6. 解释型语言，更容易**跨平台**，能够在多种操作系统上运行。 34 | 35 | Python 最主要的缺点是**执行效率低**（解释型语言的通病），如果更看重代码的执行效率，C、C++ 或 Go 可能是你更好的选择。 36 | 37 | #### Python的应用领域 38 | 39 | 目前 Python 在桌面应用开发、Web 服务器开发、云基础设施开发、网络数据采集、数据分析、量化交易、机器学习、自动化等领域都有用武之地。很多一线互联网公司都使用 Python 来开发各类支撑系统、实现自动化测试和自动化运维；还有很多公司用 Python 进行大数据处理，从数据采集、数据清洗到最终的数据呈现，Python 都提供了完美的解决方案，帮助企业从数据中发现商业价值；此外，做量化交易尤其是高频交易的操盘手，都倾向于使用 Python 语言来接入交易系统并编写交易策略。 40 | 41 | ### 安装Python环境 42 | 43 | 工欲善其事，必先利其器。想要开始你的 Python 编程之旅，首先得在计算机上安装 Python 环境，简单的说就是安装运行 Python 程序需要的 Python 解释器。我们推荐大家安装官方的 Python 3解释器，它是用 C 语言编写的，我们通常也称之为 CPython，它应该是你目前最好的选择。首先，我们需要从[官方网站下载页面](https://www.python.org/downloads/)找到并下载适合自己操作系统的 Python 3安装程序，如下图所示。 44 | 45 | 46 | 47 | 48 | 49 | #### Windows环境 50 | 51 | 下面我们以 Windows 11为例，讲解如何在 Windows 操作系统上安装 Python 环境。双击运行从官网下载的安装程序，会打开一个安装向导，画面如下所示。首先，一定要记得勾选“Add python.exe to PATH”选项，它会帮助我们将 Python 解释器添加到 Windows 系统的 PATH 环境变量中（不理解没关系，勾上就对了）；其次，“Use admin privileges when installing py.exe”是为了在安装过程中获得管理员权限，建议勾选。然后，我们选择“Customize Installation”，使用自定义安装的模式，这是专业人士的选择，而你就（假装）是那个专业人士，不建议使用“Install Now”（默认安装）。 52 | 53 | 54 | 55 | 接下来，安装向导会提示你勾选需要的“Optional Features”（可选特性），这里咱们可以直接全选。值得一提的是其中的第2项，它是 Python 的包管理工具 pip，可以帮助我们安装三方库和三方工具，所以一定要记得勾选它，然后点击“Next”进入下一环节。 56 | 57 | 58 | 59 | 接下来是对“Advanced Options”（高级选项）的选择，这里我们建议大家只勾选“Add Python to environment variables”和“Precompile standard library”这两个选项，前者会帮助我们自动配置好环境变量，后者会预编译标准库（生成`.pyc`文件），这样在使用时就无需临时编译了。还是那句话，不理解没关系，勾上就对了。下面的“Customize install location”（自定义安装路径）强烈建议修改为自定义的路径，这个路径中不应该包含中文、空格或其他特殊字符，注意这一点会为你减少很多不必要的麻烦。设置完成后，点击“Install”开始安装。 60 | 61 | 62 | 63 | 安装成功会出现如下图所示的画面，安装成功的关键词是“successful”，如果安装失败，这里的单词会变成“failed”。 64 | 65 | 66 | 67 | 安装完成后可以打开 Windows 的“命令行提示符”或 PowerShell，然后输入`python --version`或`python -V`来检查安装是否成功，这个命令是查看 Python 解释器的版本号。如果看到如下所示的画面，那么恭喜你，Python 环境已经安装成功了。这里我们建议再检查一下 Python 的包管理工具 pip 是否可用，对应的命令是`pip --version`或`pip -V`。 68 | 69 | 70 | 71 | > **说明**：如果安装过程报错或提示安装失败，很有可能是你的 Windows 系统缺失了一些动态链接库文件或缺少必要的构建工具导致的。可以在[微软官网](https://visualstudio.microsoft.com/zh-hans/downloads/)下载“Visual Studio 2022 生成工具”进行修复，如下图所示。如果不方便在微软官网下载的，也可以使用下面的百度云盘链接来获取修复工具，链接: https://pan.baidu.com/s/1iNDnU5UVdDX5sKFqsiDg5Q 提取码: cjs3。 72 | > 73 | > 74 | > 75 | > 上面下载的“Visual Studio 2022 生成工具”需要联网才能运行，运行后会出现如下图所示的画面，大家可以参考下图勾选对应的选项进行修复。修复过程需要联网下载对应的软件包，这个过程可能会比较耗时间，修复成功后可能会要求重启你的操作系统。 76 | > 77 | > 78 | 79 | #### macOS环境 80 | 81 | macOS 安装 Python 环境相较于 Windows 系统更为简单，我们从官方下载的安装包是一个`pkg`文件，双击运行之后不断的点击“继续”就安装成功了，几乎不用做任何的设置和勾选，如下图所示。 82 | 83 | 84 | 85 | 安装完成后，可以在 macOS 的“终端”工具中输入`python3 --version`命令来检查是否安装成功，注意这里的命令是`python3`不是`python`！！！然后我们再检查一下包管理工具，输入命令`pip3 --version`，如下图所示。 86 | 87 | 88 | 89 | ### 总结 90 | 91 | 总结下这一课学到的东西： 92 | 93 | 1. Python 语言很强大，可以做很多的事情，也值得我们去学习。 94 | 2. 要使用 Python语言，首先得安装 Python 环境，也就是运行 Python 程序所需的 Python 解释器。 95 | 3. Windows 系统可以在命令提示符或 PowerShell 中输入`python --version`检查 Python 解释器的版本；macOS 系统可以在终端中输入`python3 --version`检查 Python 解释器的版本。 96 | -------------------------------------------------------------------------------- /第02课：第一个Python程序.md: -------------------------------------------------------------------------------- 1 | ## 第02课：第一个Python程序 2 | 3 | 在上一课中，我们对 Python 语言的过去现在有了一些了解，我们准备好了运行 Python 程序所需要的解释器环境。相信大家已经迫不及待的想开始自己的 Python 编程之旅了，但是新问题来了，我们应该在什么地方书写 Python 程序，然后又怎么运行它呢？ 4 | 5 | ### 编写和运行代码的工具 6 | 7 | 下面我们为大家讲解几种可以编写和运行 Python 代码的工具，大家可以根据自己的需求来选择合适的工具。当然，对于初学者，我个人比较推荐使用 PyCharm，因为它不需要太多的配置也非常的强大，对新手还是很友好的。 8 | 9 | #### 默认的交互式环境 10 | 11 | 我们打开Windows的“命令提示符”或“PowerShell”工具，输入`python`然后按下`Enter`键，这个命令会把我们带到一个交互式环境中。所谓交互式环境，就是我们输入一行代码并按下`Enter`键，代码马上会被执行，如果代码有产出结果，那么结果会被显示在窗口中，如下所示。 12 | 13 | ```Bash 14 | Python 3.10.10 15 | Type "help", "copyright", "credits" or "license" for more information. 16 | >>> 2 * 3 17 | 6 18 | >>> 2 + 3 19 | 5 20 | >>> 21 | ``` 22 | 23 | > **说明**：使用 macOS 系统的用户需要打开“终端”工具，输入`python3`进入交互式环境。 24 | 25 | 如果希望退出交互式环境，可以在交互式环境中输入`quit()`，如下所示。 26 | 27 | ```Bash 28 | >>> quit() 29 | ``` 30 | 31 | #### 更好的交互式环境 - IPython 32 | 33 | 上面说的交互式环境用户体验并不怎么好，大家使用一下就能清晰的感受到。我们可以用 IPython 来替换掉它，因为 IPython 提供了更为强大的编辑和交互功能。我们可以使用 Python 的包管理工具`pip`来安装 IPython，如下所示。 34 | 35 | ```bash 36 | pip install ipython 37 | ``` 38 | 39 | > **提示**：在使用上面的命令安装 IPython 之前，可以先通过`pip config set global.index-url https://pypi.doubanio.com/simple`命令或`pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/`将下载源修改为国内的豆瓣镜像或清华镜像，否则下载安装的过程可能会非常的缓慢。 40 | 41 | 接下来可以使用下面的命令启动 IPython，进入交互式环境。 42 | 43 | ```bash 44 | ipython 45 | ``` 46 | 47 | > **说明**：还有一个网页版的 IPython 名字叫 Jupyter，由于暂时用不上它们，我们在其他的地方再给大家介绍。 48 | 49 | #### 文本编辑神器 - Visual Studio Code 50 | 51 | Visual Studio Code 是由微软开发能够在 Windows、 Linux 和 macOS 等操作系统上运行的代码编辑神器。它支持语法高亮、自动补全、多点编辑、运行调试等一系列便捷功能，而且能够支持多种编程语言。如果大家要选择一款高级文本编辑工具，强烈推荐 Visual Studio Code，关于它的[下载](https://code.visualstudio.com/)、安装和使用，有兴趣的读者可以自行研究。 52 | 53 | 54 | 55 | #### 集成开发环境 - PyCharm 56 | 57 | 如果用 Python 语言开发商业项目，我们推荐大家使用更为专业的工具 PyCharm。PyCharm 是由捷克一家名为 [JetBrains](https://www.jetbrains.com/) 的公司针对 Python 语言提供的集成开发环境（IDE)。所谓集成开发环境，通常是指提供了编写代码、运行代码、调试代码、分析代码、版本控制等一系列强大功能和便捷操作的开发工具，因此特别适合用于商业项目的开发。我们可以在 JetBrains 公司的官方网站上找到 PyCharm 的[下载链接]()，如下图所示。 58 | 59 | 60 | 61 | 官方提供了两个 PyCharm 的版本，一个是免费的社区版（Community Edition），功能相对弱小，但对于初学者来说是完全够用的；另一个是付费的专业版（Professional Edition），功能非常强大，但需要按年或按月支付费用，新用户可以免费试用30天时间。PyCharm 的安装没有任何难度，运行下载的安装程序，几乎全部使用默认设置进行安装就可以了，其中有一个步骤可以按照下图所示，勾选“创建桌面快捷方式”和“在右键菜单中添加"Open Folder as Project"”就可以了。 62 | 63 | 64 | 65 | 第一次运行 PyCharm 时，在提示你导入 PyCharm 设置的界面上直接选择“Do not import settings”，然后我们就可以看到如下图所示的欢迎界面。此处，我们可以先点击“Customize”选项对 PyCharm 做一些个性化的设置。 66 | 67 | 68 | 69 | 接下来，我们可以在“Projects”选项中点击“New Project”来创建一个新的项目，此处还可以“打开已有项目”或“从版本控制服务器（VCS）获取项目”，如下图所示。 70 | 71 | 72 | 73 | 创建项目的时候需要指定项目的路径并创建”虚拟环境“，我们建议每个 Python 都在自己专属的虚拟环境中运行。如果你的系统上还没 Python 环境，那么 PyCharm 会提供官网的下载链接，当你点击“Create”按钮创建项目时，它会联网下载 Python 解释器，如下图所示。 74 | 75 | 76 | 77 | 当然，我们并不推荐这么做，因为我们在上一课已经安装过 Python 环境了。在系统有 Python 环境的情况下，PyCharm 通常会自动发现 Python 解释器的位置并以此为基础创建虚拟环境，所以大家看到的画面应该如下图所示。 78 | 79 | 80 | 81 | > **说明**：上面的截图来自于 Windows 系统，如果使用 macOS 系统，你看到的项目路径和 Python 解释器路径会跟上面有所不同。 82 | 83 | 创建好项目后会出现如下图所示的画面，我们可以通过在项目文件夹上点击鼠标右键，选择“New”菜单下的“Python File”来创建一个 Python 文件，在给文件命名时建议使用英文字母和下划线的组合，创建好的 Python 文件会自动打开，进入可编辑的状态。 84 | 85 | 86 | 87 | 接下来，我们可以在代码窗口编写我们的 Python 代码。写好代码后，可以在窗口中点击鼠标右键，选择“Run”菜单项来运行代码，下面的“Run”窗口会显示代码的执行结果，如下图所示。 88 | 89 | 90 | 91 | 到这里，我们的第一个 Python 程序已经运转起来了，很酷吧！对了，PyCharm 有一个叫“每日小贴士”的弹窗，会教给你一些使用 PyCharm 的小技巧，如下图所示。如果不需要，直接关闭就可以了；如果不希望它再次出现，在关闭前可以勾选“Don't show tips on startup”。 92 | 93 | 94 | 95 | ### 你好世界 96 | 97 | 按照行业惯例，我们学习任何一门编程语言写的第一个程序都是输出`hello, world`，因为这段代码是伟大的丹尼斯·里奇（C 语言之父，和肯·汤普森一起开发了 Unix 操作系统）和布莱恩·柯尼汉（awk 语言的发明者）在他们的不朽著作《*The C Programming Language*》中写的第一段代码，下面是对应的 Python 语言的版本。 98 | 99 | ```Python 100 | print('hello, world') 101 | ``` 102 | 103 | > **注意**：上面代码中的圆括号、单引号都是在英文输入法状态下输入的，如果不小心写成了中文的圆括号或单引号，运行代码时会出现`SyntaxError: invalid character '（' (U+FF08)`或`SyntaxError: invalid character '‘' (U+2018)`这样的错误提示。 104 | 105 | 上面的代码只有一个语句，在这个语句中，我们用到了一个名为`print`的函数，它可以帮助我们输出指定的内容；`print`函数圆括号中的`'hello, world'`是一个字符串，它代表了一段文本内容；在 Python 语言中，我们可以用单引号或双引号来表示一个字符串。不同于 C、C++ 或 Java 这样的编程语言，Python 代码中的语句不需要用分号来表示结束，也就是说，如果我们想再写一条语句，只需要回车换行即可，代码如下所示。此外，Python 代码也不需要通过编写名为`main`的入口函数来使其运行，提供入口函数是编写可执行的 C、C++ 或 Java 代码必须要做的事情，这一点很多程序员都不陌生，但是在 Python 语言中它并不是必要的。 106 | 107 | ```Python 108 | print('hello, world') 109 | print('goodbye, world') 110 | ``` 111 | 112 | 如果不使用 PyCharm 这样的集成开发环境，我们也可以直接调用 Python 解释器来运行 Python 程序。我们可以将上面的代码保存成一个名为`example01.py`的文件，对于Windows 系统，我们假设该文件在`C:\code\`目录下，我们打开“命令提示符”或“PowerShell”并输入下面的命令就可以运行它。 113 | 114 | ```powershell 115 | python C:\code\example01.py 116 | ``` 117 | 118 | 对于 macOS 系统，假设我们的文件在`/Users/Hao/`目录下，那么可以在终端中输入下面的命令来运行程序。 119 | 120 | ```Bash 121 | python3 /Users/Hao/example01.py 122 | ``` 123 | 124 | > **提示**：如果路径比较长，不愿意手动输入，我们可以通过拖拽的方式将文件直接拖到“命令提示符”或“终端”中，这样会自动输入完整的文件路径。 125 | 126 | 大家可以试着修改上面的代码，比如将单引号中的`hello, world`换成其他内容或者多写几个这样的语句，看看会运行出怎样的结果。需要提醒大家的是，写 Python 代码时，最好每一行只写一条语句。虽然，我们可以使用`;`作为分隔将多个语句写在一行中，但是这样做会让代码变得非常难看，不再具备良好的可读性。 127 | 128 | ### 注释你的代码 129 | 130 | 注释是编程语言的一个重要组成部分，用于在代码中解释代码的作用，从而达到增强代码可读性的目标。当然，我们也可以将代码中暂时不需要运行的代码段通过添加注释来去掉，这样当你需要重新使用这些代码的时候，去掉注释符号就可以了。简单的说，**注释会让代码更容易看懂但不会影响代码的执行结果**。 131 | 132 | Python 中有两种形式的注释： 133 | 134 | 1. 单行注释：以`#`和空格开头，可以注释掉从`#`开始后面一整行的内容。 135 | 2. 多行注释：三个引号（通常用双引号）开头，三个引号结尾，通常用于添加多行说明性内容。 136 | 137 | ```Python 138 | """ 139 | 第一个Python程序 - hello, world 140 | 141 | Version: 1.0 142 | Author: 骆昊 143 | """ 144 | # print('hello, world') 145 | print("你好，世界！") 146 | ``` 147 | 148 | ### 总结 149 | 150 | 到此，我们已经把第一个 Python 程序运行起来了，是不是很有成就感？！只要你坚持学习下去，再过一段时间，我们就可以用 Python 语言做更多更酷的事情。今时今日，编程就跟英语一样，对很多人来说都是一项必须要掌握的技能。 151 | -------------------------------------------------------------------------------- /第03课：Python语言中的变量.md: -------------------------------------------------------------------------------- 1 | ## 第03课：Python语言中的变量 2 | 3 | 对于想学习编程的新手来说，有两个问题可能是他们很想知道的，其一是“什么是（计算机）程序”，其二是“写（计算机）程序能做什么”。先说说我对这两个问题的理解：**程序是数据和指令的有序集合**，**写程序就是用数据和指令控制计算机做我们想让它做的事情**。今时今日，为什么有那么多人选择用 Python 语言来写程序，因为 Python 语言足够简单和强大。相较于 C、C++、Java 这样的编程语言，Python 对初学者和非专业人士更加友好，我们想做的很多事情，在 Python 语言中都能找到简单优雅的解决方案。接下来，我们就从最基础的语言元素开始，带大家认识和使用 Python 语言。 4 | 5 | ### 一些计算机常识 6 | 7 | 在开始系统的学习编程之前，我们先来科普一些计算机的基础知识。计算机的硬件系统通常由五大部件构成，包括：**运算器**、**控制器**、**存储器**、**输入设备**和**输出设备**。其中，运算器和控制器放在一起就是我们常说的**中央处理器**（CPU），它的功能是执行各种运算和控制指令。刚才我们提到过程序是指令的集合，写程序就是将一系列的指令按照某种方式组织到一起，然后通过这些指令去控制计算机做我们想让它做的事情。存储器可以分为**内部存储器**和**外部存储器**，前者就是我们常说的内存，它是中央处理器可以直接寻址的存储空间，程序在执行的过程中，对应的数据和指令需要加载到内存中。输入设备和输出设备经常被统称为 I/O 设备，键盘、鼠标、麦克风、摄像头是典型的输入设备，而显示器、打印机、扬声器等则是典型的输出设备。目前，我们使用的计算机基本都是遵循“冯·诺依曼体系结构”的计算机，这种计算机有两个关键点：一是**将存储器与中央处理器分开**；二是**将数据以二进制方式编码**。 8 | 9 | 二进制是一种“逢二进一”的计数法，跟人类使用的“逢十进一”的计数法本质是一样的。人类因为有十根手指，所以使用了十进制计数法，在计数时十根手指用完之后，就只能用进位的方式来表示更大的数值。当然凡事都有例外，玛雅人可能是因为长年光着脚的原因，把脚趾头也都用上了，于是他们使用了二十进制的计数法。基于这样的计数方式，玛雅人使用的历法跟我们平常使用的历法就产生了差异。按照玛雅人的历法，2012年是上一个所谓的“太阳纪”的最后一年，而2013年则是新的“太阳纪”的开始。后来这件事情还被以讹传讹的方式误传为“2012年是玛雅人预言的世界末日”的荒诞说法。今天有很多人猜测，玛雅文明之所以发展缓慢跟使用了二十进制是有关系的。对于计算机来说，二进制在物理器件上最容易实现的，因为可以用高电压表示1，用低电压表示0。不是所有写程序的人都需要熟悉二进制，熟悉十进制与二进制、八进制、十六进制的转换，大多数时候我们即便不了解这些知识也能写程序。但是，我们必须知道，计算机是使用二进制计数的，不管什么样的数据，到了计算机内存中都是以二进制形态存在的。 10 | 11 | > **说明**：关于二进制计数法以及它与其他进制如何相互转换，随便找本名为《计算机导论》或《计算机文化》的书，都能找到相应的知识，此处就不再进行赘述了，不清楚的读者可以自行研究。 12 | 13 | ### 变量和类型 14 | 15 | 要想在计算机的内存中保存数据，首先得说一说变量这个概念。在编程语言中，**变量是数据的载体**，简单的说就是一块用来保存数据的内存空间，**变量的值可以被读取和修改**，这是所有运算和控制的基础。计算机能处理的数据有很多种类型，最常见的就是数值，除了数值之外还有文本、图像、音频、视频等各种各样的数据类型。虽然数据在计算机中都是以二进制形态存在的，但是我们可以用不同类型的变量来表示数据类型的差异。Python 语言中预设了多种数据类型，也允许我们自定义新的数据类型，这一点在后面会讲到。我们首先来了解几种 Python 中最为常用的数据类型。 16 | 17 | 1. 整型（`int`）：Python 中可以处理任意大小的整数，而且支持二进制（如`0b100`，换算成十进制是4）、八进制（如`0o100`，换算成十进制是64）、十进制（`100`）和十六进制（`0x100`，换算成十进制是256）的表示法。运行下面的代码，看看会输出什么。 18 | 19 | ```Python 20 | print(0b100) # 二进制整数 21 | print(0o100) # 八进制整数 22 | print(100) # 十进制整数 23 | print(0x100) # 十六进制整数 24 | ``` 25 | 26 | 2. 浮点型（`float`）：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如`123.456`）之外还支持科学计数法（如`1.23456e2`，表示$\small{1.23456 \times 10^{2}}$）。运行下面的代码，看看会输出什么。 27 | 28 | ```Python 29 | print(123.456) # 数学写法 30 | print(1.23456e2) # 科学计数法 31 | ``` 32 | 33 | 3. 字符串型（`str`）：字符串是以单引号或双引号包裹起来的任意文本，比如`'hello'`和`"hello"`。 34 | 35 | 4. 布尔型（`bool`）：布尔型只有`True`、`False`两种值，要么是`True`，要么是`False`，可以用来表示现实世界中的“是”和“否”，命题的“真”和“假”，状况的“好”与“坏”，水平的“高”与“低”等等。如果一个变量的值只有两种状态，我们就可以使用布尔型。 36 | 37 | ### 变量命名 38 | 39 | 对于每个变量，我们都需要给它取一个名字，就如同我们每个人都有自己的名字一样。在 Python 中，变量命名需要遵循以下的规则和惯例。 40 | 41 | - 规则部分： 42 | - 规则1：变量名由**字母**、**数字**和**下划线**构成，数字不能开头。需要说明的是，这里说的字母指的是 Unicode 字符，Unicode 称为万国码，囊括了世界上大部分的文字系统，这也就意味着中文、日文、希腊字母等都可以作为变量名中的字符，但是一些特殊字符（如：`！`、`@`、`#`等）是不能出现在变量名中的。我们强烈建议大家把这里说的字母理解为**尽可能只使用英文字母**。 43 | - 规则2：Python 是**大小写敏感**的编程语言，简单的说就是大写的`A`和小写的`a`是两个不同的变量，这一条其实并不算规则，而是需要大家注意的地方。 44 | - 规则3：变量名**不要跟 Python 的关键字重名**，**尽可能避开 Python 的保留字**。这里的关键字是指在 Python 程序中有特殊含义的单词（如：`is`、`if`、`else`、`for`、`while`、`True`、`False`等），保留字主要指 Python 语言内置函数、内置模块等的名字（如：`int`、`print`、`input`、`str`、`math`、`os`等）。 45 | - 惯例部分： 46 | - 惯例1：变量名通常使用小写英文字母，多个单词用下划线进行连接。 47 | - 惯例2：受保护的变量用单个下划线开头。 48 | - 惯例3：私有的变量用两个下划线开头。 49 | 50 | 惯例2和惯例3大家暂时不用理解，讲到后面自然会明白的。当然，作为一个专业的程序员，给变量命名时做到**见名知意**也是非常重要，这彰显了一个程序员的专业气质，很多开发岗位的面试也非常看重这一点。 51 | 52 | ### 变量的使用 53 | 54 | 下面通过例子来说明变量的类型和变量的使用。 55 | 56 | ```Python 57 | """ 58 | 使用变量保存数据并进行加减乘除运算 59 | 60 | Version: 1.0 61 | Author: 骆昊 62 | """ 63 | a = 45 # 定义变量a，赋值45 64 | b = 12 # 定义变量b，赋值12 65 | print(a, b) # 45 12 66 | print(a + b) # 57 67 | print(a - b) # 33 68 | print(a * b) # 540 69 | print(a / b) # 3.75 70 | ``` 71 | 72 | 在 Python 中可以使用`type`函数对变量的类型进行检查。程序设计中函数的概念跟数学上函数的概念非常类似，数学上的函数相信大家并不陌生，它包括了函数名、自变量和因变量。如果暂时不理解函数这个概念也不要紧，我们会在后续的内容中专门讲解函数的定义和使用。 73 | 74 | ```Python 75 | """ 76 | 使用type函数检查变量的类型 77 | 78 | Version: 1.0 79 | Author: 骆昊 80 | """ 81 | a = 100 82 | b = 123.45 83 | c = 'hello, world' 84 | d = True 85 | print(type(a)) # 86 | print(type(b)) # 87 | print(type(c)) # 88 | print(type(d)) # 89 | ``` 90 | 91 | 可以通过 Python 内置的函数来改变变量的类型，下面是一些常用的和变量类型相关的函数。 92 | 93 | - `int()`：将一个数值或字符串转换成整数，可以指定进制。 94 | - `float()`：将一个字符串（在可能的情况下）转换成浮点数。 95 | - `str()`：将指定的对象转换成字符串形式，可以指定编码方式。 96 | - `chr()`：将整数（字符编码）转换成对应的（一个字符的）字符串。 97 | - `ord()`：将（一个字符的）字符串转换成对应的整数（字符编码）。 98 | 99 | 下面的例子为大家演示了Python中类型转换的操作。 100 | 101 | ```Python 102 | """ 103 | 变量的类型转换操作 104 | 105 | Version: 1.0 106 | Author: 骆昊 107 | """ 108 | a = 100 109 | b = 123.45 110 | c = '123' 111 | d = '100' 112 | e = '123.45' 113 | f = 'hello, world' 114 | g = True 115 | print(float(a)) # int类型的100转成float，输出100.0 116 | print(int(b)) # float类型的123.45转成int，输出123 117 | print(int(c)) # str类型的'123'转成int，输出123 118 | print(int(c, base=16)) # str类型的'123'按十六进制转成int，输出291 119 | print(int(d, base=2)) # str类型的'100'按二进制转成int，输出4 120 | print(float(e)) # str类型的'123.45'转成float，输出123.45 121 | print(bool(f)) # str类型的'hello, world'转成bool，输出True 122 | print(int(g)) # bool类型的True转成int，输出1 123 | print(chr(a)) # int类型的100转成str，输出'd' 124 | print(ord('d')) # str类型的'd'转成int，输出100 125 | ``` 126 | 127 | > **说明**：`str`类型转`int`类型时可以通过`base`参数来指定进制，可以将字符串视为对应进制的整数进行转换。`str`类型转成`bool`类型时，只要字符串有内容，不是`''`或`""`，对应的布尔值都是`True`。`bool`类型转`int`类型时，`True`会变成`1`，`False`会变成`0`。在 ASCII 字符集和 Unicode 字符集中， 字符`'d'`对应的编码都是`100`。 128 | 129 | ### 总结 130 | 131 | 在 Python 程序中，我们可以**使用变量来保存数据**，**变量有不同的类型**，常用的类型有`int`、`float`、`str`和`bool`。在有需要的情况下，可以通过 Python 内置的函数对变量进行类型转换。变量是可以做运算的，这是解决很多问题的先决条件，我们会在下一课中为大家详细介绍变量的运算。 132 | -------------------------------------------------------------------------------- /第04课：Python语言中的运算符.md: -------------------------------------------------------------------------------- 1 | ## 第04课：Python语言中的运算符 2 | 3 | Python 语言支持很多种运算符，下面的表格按照运算符的优先级从高到低，对 Python 中的运算符进行了罗列。有了变量和运算符，我们就可以构造各种各样的表达式来解决实际问题。在计算机科学中，**表达式是计算机程序中的句法实体，它由一个或多个常量、变量、函数和运算符组合而成，编程语言可以对其进行解释和计算以得到另一个值**。不管使用什么样的编程语言，构造表达式都是非常重要的。 4 | 5 | | 运算符 | 描述 | 6 | | ------------------------------------------------------------ | ------------------------------ | 7 | | `[]`、`[:]` | 索引、切片 | 8 | | `**` | 幂 | 9 | | `~`、`+`、`-` | 按位取反、正号、负号 | 10 | | `*`、`/`、`%`、`//` | 乘、除、模、整除 | 11 | | `+`、`-` | 加、减 | 12 | | `>>`、`<<` | 右移、左移 | 13 | | `&` | 按位与 | 14 | | `^`、`|` | 按位异或、按位或 | 15 | | `<=`、`<`、`>`、`>=` | 小于等于、小于、大于、大于等于 | 16 | | `==`、`!=` | 等于、不等于 | 17 | | `is`、`is not` | 身份运算符 | 18 | | `in`、`not in` | 成员运算符 | 19 | | `not`、`or`、`and` | 逻辑运算符 | 20 | | `=`、`+=`、`-=`、`*=`、`/=`、`%=`、`//=`、`**=`、`&=`、`|=`、`^=`、`>>=`、`<<=` | 赋值运算符 | 21 | 22 | >**说明**： 所谓优先级就是在一个运算的表达式中，如果出现了多个运算符，应该先执行什么再执行什么的顺序。编写代码的时候，如果搞不清楚一个表达式中运算符的优先级，可以使用圆括号来确保运算的执行顺序。 23 | 24 | ### 算术运算符 25 | 26 | Python 中的算术运算符非常丰富，除了大家最为熟悉的加、减、乘、除之外，还有整除运算符、求模（求余数）运算符和求幂运算符。下面的例子为大家展示了算术运算符的使用。 27 | 28 | ```python 29 | """ 30 | 算术运算符 31 | 32 | Version: 1.0 33 | Author: 骆昊 34 | """ 35 | print(321 + 12) # 加法运算，输出333 36 | print(321 - 12) # 减法运算，输出309 37 | print(321 * 12) # 乘法运算，输出3852 38 | print(321 / 12) # 除法运算，输出26.75 39 | print(321 // 12) # 整除运算，输出26 40 | print(321 % 12) # 求模运算，输出9 41 | print(321 ** 12) # 求幂运算，输出1196906950228928915420617322241 42 | ``` 43 | 44 | 算术运算需要先乘除后加减，这一点跟数学课本中讲的知识没有区别，也就是说乘除法的运算优先级是高于加减法的。如果还有求幂运算，求幂运算的优先级是高于乘除法的。如果想改变算术运算的执行顺序，可以使用英文输入法状态下的圆括号（小括号），写在圆括号中的表达式会被优先执行，如下面的例子所示。 45 | 46 | ```python 47 | """ 48 | 算术运算的优先级 49 | 50 | Version: 1.0 51 | Author: 骆昊 52 | """ 53 | print(2 + 3 * 5) # 17 54 | print((2 + 3) * 5) # 25 55 | print((2 + 3) * 5 ** 2) # 125 56 | print(((2 + 3) * 5) ** 2) # 625 57 | ``` 58 | 59 | ### 赋值运算符 60 | 61 | 赋值运算符应该是最为常见的运算符，它的作用是将右边的值赋给左边的变量。赋值运算符还可以跟上面的算术运算符放在一起，组合成复合赋值运算符，例如：`a += b`相当于`a = a + b`，`a *= a + 2`相当于`a = a * (a + 2)`。下面的例子演示了赋值运算符和复合赋值运算符的使用。 62 | 63 | ```python 64 | """ 65 | 赋值运算符和复合赋值运算符 66 | 67 | Version: 1.0 68 | Author: 骆昊 69 | """ 70 | a = 10 71 | b = 3 72 | a += b # 相当于：a = a + b 73 | a *= a + 2 # 相当于：a = a * (a + 2) 74 | print(a) # 大家算一下这里会输出什么 75 | ``` 76 | 77 | > **注意**：赋值运算构成的表达式本身不产生任何值，为了解决这个问题，Python 3.8中引入了一个新的赋值运算符`:=`，我们通常称之为海象运算符，大家可以猜一猜它为什么叫这个名字，我们在后面用到的时候再为大家讲解这个运算符。 78 | 79 | ### 比较运算符和逻辑运算符 80 | 81 | 比较运算符也称为关系运算符，包括`==`、`!=`、`<`、`>`、`<=`、`>=`，我相信大家一看就能懂。需要提醒的是比较相等用的是`==`，请注意这里是两个等号，因为`=`是赋值运算符，我们在上面刚刚讲到过。比较不相等用的是`!=`，跟数学课本中使用的$\small{\neq}$并不相同，Python 2中曾经使用过`<>`来表示不等于，在 Python 3中使用`<>`会引发`SyntaxError`（语法错误）。比较运算符会产生布尔值，要么是`True`，要么是`False`。 82 | 83 | 逻辑运算符有三个，分别是`and`、`or`和`not`。`and`字面意思是“而且”，所以`and`运算符会连接两个布尔值或者产生布尔值的表达式，如果两边的布尔值都是`True`，那么运算的结果就是`True`；左右两边的布尔值有一个是`False`，最终的运算结果就是`False`。当然，如果`and`运算符左边的布尔值是`False`，不管右边的布尔值是什么，最终的结果都是`False`，这时运算符右边的布尔值会被跳过（专业的说法叫短路处理，如果`and`右边是一个表达式，那么这个表达式不会执行）。`or`字面意思是“或者”，所以`or`运算符也会连接两个布尔值或产生布尔值的表达式，如果两边的布尔值有任意一个是`True`，那么最终的结果就是`True`。当然，`or`运算符也是有短路功能的，当它左边的布尔值为`True`的情况下，右边的布尔值会被短路（如果`or`右边是一个表达式，那么这个表达式不会执行）。`not`运算符的后面可以跟一个布尔值，如果`not`后面的布尔值或表达式是`True`，那么运算的结果就是`False`；如果`not`后面的布尔值或表达式是`False`，那么运算的结果就是`True`。 84 | 85 | ```python 86 | """ 87 | 比较运算符和逻辑运算符的使用 88 | 89 | Version: 1.0 90 | Author: 骆昊 91 | """ 92 | flag0 = 1 == 1 93 | flag1 = 3 > 2 94 | flag2 = 2 < 1 95 | flag3 = flag1 and flag2 96 | flag4 = flag1 or flag2 97 | flag5 = not flag0 98 | print('flag0 =', flag0) # flag0 = True 99 | print('flag1 =', flag1) # flag1 = True 100 | print('flag2 =', flag2) # flag2 = False 101 | print('flag3 =', flag3) # flag3 = False 102 | print('flag4 =', flag4) # flag4 = True 103 | print('flag5 =', flag5) # flag5 = False 104 | print(flag1 and not flag2) # True 105 | print(1 > 2 or 2 == 3) # False 106 | ``` 107 | 108 | > **说明**：比较运算符的优先级高于赋值运算符，所以上面的`flag0 = 1 == 1`先做`1 == 1`产生布尔值`True`，再将这个值赋值给变量`flag0`。`print`函数可以输出多个值，多个值之间可以用`,`进行分隔，输出的内容默认以空格分开。 109 | 110 | ### 运算符和表达式应用举例 111 | 112 | #### 例子1：华氏温度转摄氏温度 113 | 114 | 要求：输入华氏温度将其转换为摄氏温度，华氏温度到摄氏温度的转换公式为：$\small{C = (F - 32) / 1.8}$。 115 | 116 | ```python 117 | """ 118 | 将华氏温度转换为摄氏温度 119 | 120 | Version: 1.0 121 | Author: 骆昊 122 | """ 123 | f = float(input('请输入华氏温度: ')) 124 | c = (f - 32) / 1.8 125 | print('%.1f华氏度 = %.1f摄氏度' % (f, c)) 126 | ``` 127 | 128 | > **说明**：上面代码中的`input`函数用于从键盘接收用户输入，由于输入的都是字符串，如果想处理成浮点小数来做后续的运算，可以用我们上一课讲解的类型转换的方法，用`float`函数将`str`类型处理成`float`类型。 129 | 130 | 上面的代码中，我们对`print`函数输出的内容进行了格式化处理，`print`输出的字符串中有两个`%.1f`占位符，这两个占位符会被`%`之后的`(f, c)`中的两个`float`类型的变量值给替换掉，浮点数小数点后保留1位有效数字。如果字符串中有`%d`占位符，那么我们会用`int`类型的值替换掉它，如果字符串中有`%s`占位符，那么它会被`str`类型的值替换掉。 131 | 132 | 除了上面格式化输出的方式外，Python 中还可以用下面的办法来格式化输出，我们给出一个带占位符的字符串，字符串前面的`f`表示这个字符串是需要格式化处理的，其中的`{f:.1f}`和`{c:.1f}`可以先看成是`{f}`和`{c}`，表示输出时会用变量`f`和变量`c`的值替换掉这两个占位符，后面的`:.1f`表示这是一个浮点数，小数点后保留1位有效数字。 133 | 134 | ```python 135 | """ 136 | 将华氏温度转换为摄氏温度 137 | 138 | Version: 1.1 139 | Author: 骆昊 140 | """ 141 | f = float(input('请输入华氏温度: ')) 142 | c = (f - 32) / 1.8 143 | print(f'{f:.1f}华氏度 = {c:.1f}摄氏度') 144 | ``` 145 | 146 | #### 例子2：计算圆的周长和面积 147 | 148 | 要求：输入一个圆的半径，计算出它的周长（$\small{2 \pi r}$）和面积（$\small{\pi r^{2}}$）。 149 | 150 | ```python 151 | """ 152 | 输入半径计算圆的周长和面积 153 | 154 | Version: 1.0 155 | Author: 骆昊 156 | """ 157 | radius = float(input('请输入圆的半径: ')) 158 | perimeter = 2 * 3.1416 * radius 159 | area = 3.1416 * radius * radius 160 | print('周长: %.2f' % perimeter) 161 | print('面积: %.2f' % area) 162 | ``` 163 | 164 | Python 中有一个名为`math` 的内置模块，该模块中定义了名为`pi`的变量，它的值就是圆周率。如果要使用 Python 内置的这个`pi`，我们可以对上面的代码稍作修改。 165 | 166 | ```python 167 | """ 168 | 输入半径计算圆的周长和面积 169 | 170 | Version: 1.1 171 | Author: 骆昊 172 | """ 173 | import math 174 | 175 | radius = float(input('请输入圆的半径: ')) 176 | perimeter = 2 * math.pi * radius 177 | area = math.pi * radius ** 2 178 | print(f'周长: {perimeter:.2f}') 179 | print(f'面积: {area:.2f}') 180 | ``` 181 | 182 | > **说明**：上面代码中的`import math`表示导入`math`模块，导入该模块以后，才能用`math.pi`得到圆周率的值。 183 | 184 | 这里其实还有一种格式化输出的方式，是 Python 3.8 中增加的新特性，大家直接看下面的代码就明白了。 185 | 186 | ```python 187 | """ 188 | 输入半径计算圆的周长和面积 189 | 190 | Version: 1.2 191 | Author: 骆昊 192 | """ 193 | import math 194 | 195 | radius = float(input('请输入圆的半径: ')) # 输入: 5.5 196 | perimeter = 2 * math.pi * radius 197 | area = math.pi * radius ** 2 198 | print(f'{perimeter = :.2f}') # 输出：perimeter = 34.56 199 | print(f'{area = :.2f}') # 输出：area = 95.03 200 | ``` 201 | 202 | > **说明**：假如变量`a`的值是`9.87`，那么字符串`f'{a = }'`的值是`a = 9.87`；而字符串`f'{a = :.1f}'`的值是`a = 9.9`。这种格式化输出的方式会同时输出变量名和变量值。 203 | 204 | #### 例子3：判断闰年 205 | 206 | 要求：输入一个1582年以后的年份，判断该年份是不是闰年。 207 | 208 | ```python 209 | """ 210 | 输入年份，闰年输出True，平年输出False 211 | 212 | Version: 1.0 213 | Author: 骆昊 214 | """ 215 | year = int(input('请输入年份: ')) 216 | is_leap = year % 4 == 0 and year % 100 != 0 or year % 400 == 0 217 | print(f'{is_leap = }') 218 | ``` 219 | 220 | > **说明**：对于格里历（Gregorian calendar），即今天我们使用的公历，判断闰年的规则是：1. 公元年份非4的倍数是平年；2. 公元年份为4的倍数但非100的倍数是闰年；3. 公元年份为400的倍数是闰年。格里历是由教皇格里高利十三世在1582年10月引入的，作为对儒略历（Julian calendar）的修改和替代，我们在输入年份时要注意这一点。上面的代码通过`%`来判断`year`是不是`4`的倍数、`100`的倍数、`400`的倍数，然后用`and`和`or`运算符将三个条件组装在一起，前两个条件要同时满足，第三个条件跟前两个条件的组合只需满足其中之一。 221 | 222 | ### 总结 223 | 224 | 通过上面的讲解和例子，相信大家已经感受到了运算符和表达式的力量。实际编程中的很多问题，都需通过构造表达式来解决，所以变量、运算符、表达式对于任何一门编程语言都是极为重要的基础。如果本节课的内容有什么不理解的地方，一定不要着急进入下一课，先在评论区留言讨论，我会及时解答大家的问题。 225 | -------------------------------------------------------------------------------- /第05课：分支结构.md: -------------------------------------------------------------------------------- 1 | ## 第05课：分支结构 2 | 3 | 迄今为止，我们写的 Python 代码都是一条一条语句按顺序向下执行的，这种代码结构叫做顺序结构。然而仅有顺序结构并不能解决所有的问题，比如我们设计一个游戏，游戏第一关的过关条件是玩家获得1000分，那么在第一关完成后，我们要根据玩家得到分数来决定是进入第二关，还是告诉玩家“Game Over”。在这样的场景下，我们的代码就会产生两个分支，而且这两个分支只有一个会被执行。类似的场景还有很多，我们将这种结构称之为“分支结构”或“选择结构”。给大家一分钟的时间，你应该可以想到至少5个以上类似的例子，赶紧试一试吧！ 4 | 5 | ### 使用if和else构造分支结构 6 | 7 | 在 Python 中，要构造分支结构可以使用`if`、`elif`和`else`三个关键字。所谓**关键字**就是编程语言中有特殊含义的单词，像`if`和`else`就是专门用于构造分支结构的关键字，很显然你不能够使用它作为变量名。当然，我们并不是每次构造分支结构都会把三个关键字全部用上，下面我们通过例子加以说明。 8 | 9 | 我们来写一个身体质量指数（BMI）的计算器。身体质量质数也叫体质指数，是国际上常用的衡量人体胖瘦程度以及是否健康的一个标准，计算公式如下所示。通常认为$\small{18.5 \le BMI < 24}$是正常范围，$\small{BMI < 18.5}$说明体重过轻，$\small{BMI \ge 24}$说明体重过重，$\small{BMI \ge 27}$就属于肥胖的范畴了。 10 | 11 | $$ 12 | BMI = \frac{体重}{身高^{2}} 13 | $$ 14 | 15 | > **说明**：上面公式中的体重以千克（kg）为单位，身高以米（m）为单位。 16 | 17 | ```python 18 | """ 19 | BMI计算器 20 | 21 | Version: 1.0 22 | Author: 骆昊 23 | """ 24 | height = float(input('身高(cm)：')) 25 | weight = float(input('体重(kg)：')) 26 | bmi = weight / (height / 100) ** 2 27 | print(f'{bmi = :.1f}') 28 | if 18.5 <= bmi < 24: 29 | print('你的身材很棒！') 30 | ``` 31 | 32 | > **提示**：`if`语句的最后面有一个`:`，它是用英文输入法输入的冒号；程序中输入的`'`、`"`、`=`、`(`、`)`等特殊字符，都是在英文输入法状态下输入的，这一点之前已经提醒过大家了。很多初学者经常会忽略这一点，等到执行代码时，就会看到一大堆错误提示。当然，认真读一下错误提示还是很容易发现哪里出了问题，但是**强烈建议**大家在写代码的时候**切换到英文输入法**，这样可以避免很多不必要的麻烦。 33 | 34 | 上面的代码中，我们在计算和输出 BMI 之后，加上了一段分支结构，如果满足$\small{18.5 \le BMI < 24}$，程序会输出“你的身材很棒！”，但是如果不满足条件，这段输出就没有了。这就是我们上面说的代码有不同的执行路径，有些代码不一定会执行到。我们在`if`关键字的后面给出了一个表达式`18.5 <= bmi < 24`，之前我们说过，关系运算会产生布尔值，如果`if`后面的布尔值为`True`，那么`if`语句下方，有四个空格缩进的`print('你的身材很棒！')`就会被执行。我们先输入几组数据运行上面的代码，如下所示。 35 | 36 | 第一组输入： 37 | 38 | ``` 39 | 身高(cm)：175 40 | 体重(kg)：68 41 | bmi = 22.2 42 | 你的身材很棒！ 43 | ``` 44 | 45 | 第二组输入： 46 | 47 | ``` 48 | 身高(cm)：175 49 | 体重(kg)：95 50 | bmi = 31.0 51 | ``` 52 | 53 | 第三组输入： 54 | 55 | ``` 56 | 身高(cm)：175 57 | 体重(kg)：50 58 | bmi = 16.3 59 | ``` 60 | 61 | 只有第一组输入的身高和体重计算出的 BMI 在18.5到24这个范围值内，所以触发了`if`条件，输出了“你的身材很棒”。需要说明的是，不同于 C、C++、Java 等编程语言，Python 中没有用花括号来构造代码块而是**使用缩进的方式来表示代码的层次结构**，如果`if`条件成立的情况下需要执行多条语句，只要保持多条语句具有相同的缩进就可以了。换句话说，若干行连续的语句如果保持了相同的缩进，那么它们就属于同一个**代码块**，相当于是一个执行的整体。缩进可以使用任意数量的空格，但**通常使用4个空格**，强烈建议大家**不要使用制表键（Tab键）来缩进代码**，如果你已经习惯了这么做，可以设置你的代码编辑器自动将1个制表键变成4个空格，很多代码编辑器都支持这项功能，PyCharm 中默认也是这样设定的。还有一点，在 C、C++、Java 等编程语言中，`18.5 <= bmi < 24`要写成两个条件`bmi >= 18.5`和`bmi < 24`，然后把两个条件用逻辑与运算符连接起来，Python 中也可以这么做，例如刚才的`if`语句也可以写成`if bmi >= 18.5 and bmi < 24:`，但是没有必要，难道`if 18.5 <= bmi < 24:`这个写法它不香吗？下面用 Java 代码做了同样的事情，看不懂 Java 代码没关系，感受一下它和 Python 语法的区别就可以了。 62 | 63 | ```java 64 | import java.util.Scanner; 65 | 66 | class Test { 67 | 68 | public static void main(String[] args) { 69 | try (Scanner sc = new Scanner(System.in)) { 70 | System.out.print("身高(cm): "); 71 | double height = sc.nextDouble(); 72 | System.out.print("体重(kg): "); 73 | double weight = sc.nextDouble(); 74 | double bmi = weight / Math.pow(height / 100, 2); 75 | System.out.printf("bmi = %.1f\n", bmi); 76 | if (bmi >= 18.5 && bmi < 24) { 77 | System.out.println("你的身材很棒！"); 78 | } 79 | } 80 | } 81 | } 82 | ``` 83 | 84 | > **说明**：上面就是 BMI 计算器1.0版本对应的Java代码，欢迎在评论区吐槽它。 85 | 86 | 接下来，我们对上面的代码稍作修改，在 BMI 不满足$\small{18.5 \le BMI < 24}$的情况下，也给出相信的提示信息。我们可以在`if`代码块的后面增加一个`else`代码块，它会在`if`语句给出的条件没有达成时执行，如下所示。很显然，`if`下面的`print('你的身材很棒！')`和`else`下面的`print('你的身材不够标准哟！')`只有一个会被执行到。 87 | 88 | ```python 89 | """ 90 | BMI计算器 91 | 92 | Version: 1.1 93 | Author: 骆昊 94 | """ 95 | height = float(input('身高(cm)：')) 96 | weight = float(input('体重(kg)：')) 97 | bmi = weight / (height / 100) ** 2 98 | print(f'{bmi = :.1f}') 99 | if 18.5 <= bmi < 24: 100 | print('你的身材很棒！') 101 | else: 102 | print('你的身材不够标准哟！') 103 | ``` 104 | 105 | 如果要给出更为准确的提示信息，我们可以再次修改上面的代码，通过`elif`关键字为上面的分支结构增加更多的分支，如下所示。 106 | 107 | ```python 108 | """ 109 | BMI计算器 110 | 111 | Version: 1.2 112 | Author: 骆昊 113 | """ 114 | height = float(input('身高(cm)：')) 115 | weight = float(input('体重(kg)：')) 116 | bmi = weight / (height / 100) ** 2 117 | print(f'{bmi = :.1f}') 118 | if bmi < 18.5: 119 | print('你的体重过轻！') 120 | elif bmi < 24: 121 | print('你的身材很棒！') 122 | elif bmi < 27: 123 | print('你的体重过重！') 124 | elif bmi < 30: 125 | print('你已轻度肥胖！') 126 | elif bmi < 35: 127 | print('你已中度肥胖！') 128 | else: 129 | print('你已重度肥胖！') 130 | ``` 131 | 132 | 我们再用刚才的三组数据来测试下上面的代码，看看会得到怎样的结果。 133 | 134 | 第一组输入： 135 | 136 | ``` 137 | 身高(cm)：175 138 | 体重(kg)：68 139 | bmi = 22.2 140 | 你的身材很棒！ 141 | ``` 142 | 143 | 第二组输入： 144 | 145 | ``` 146 | 身高(cm)：175 147 | 体重(kg)：95 148 | bmi = 31.0 149 | 你已中度肥胖！ 150 | ``` 151 | 152 | 第三组输入： 153 | 154 | ``` 155 | 身高(cm)：175 156 | 体重(kg)：50 157 | bmi = 16.3 158 | 你的体重过轻！ 159 | ``` 160 | 161 | ### 使用math和case构造分支结构 162 | 163 | Python 3.10 中增加了一种新的构造分支结构的方式，通过使用`match`和`case` 关键字，我们可以轻松的构造出多分支结构。Python 的官方文档在介绍这个新语法时，举了一个 HTTP 响应状态码识别的例子，非常有意思。如果不知道什么是 HTTP 响应状态吗，可以看看 MDN 上面的[文档](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status)。下面我们对官方文档上的示例稍作修改，为大家讲解这个语法，先看看下面用`if-else`结构实现的代码。 164 | 165 | ```python 166 | status_code = int(input('响应状态码: ')) 167 | if status_code == 400: 168 | description = 'Bad Request' 169 | elif status_code == 401: 170 | description = 'Unauthorized' 171 | elif status_code == 403: 172 | description = 'Forbidden' 173 | elif status_code == 404: 174 | description = 'Not Found' 175 | elif status_code == 405: 176 | description = 'Method Not Allowed' 177 | else: 178 | description = 'Unknown status Code' 179 | print('状态码描述:', description) 180 | ``` 181 | 182 | 运行结果： 183 | 184 | ``` 185 | 响应状态码: 403 186 | 状态码描述: Forbidden 187 | ``` 188 | 189 | 下面是使用`match-case`语法实现的代码，虽然作用完全相同，但是代码显得更加简单优雅。 190 | 191 | ```python 192 | status_code = int(input('响应状态码: ')) 193 | match status_code: 194 | case 400: description = 'Bad Request' 195 | case 401: description = 'Unauthorized' 196 | case 403: description = 'Forbidden' 197 | case 404: description = 'Not Found' 198 | case 405: description = 'Method Not Allowed' 199 | case _: description = 'Unknown Status Code' 200 | print('状态码描述:', description) 201 | ``` 202 | 203 | > **说明**：带有`_`的`case`语句在代码中起到通配符的作用，如果前面的分支都没有匹配上，代码就会来到`case _`。`case _`的使用是可选的，并非每种分支结构都要给出通配符选项。如果分支中出现了`case _`，它只能放在分支结构的最后面，如果它的后面还有其他的分支，那么这些分支将是不可达的。 204 | 205 | 当然，`match-case`语法还有很多高级玩法，我们等用到时候再为大家讲解，有一个合并模式可以在这里分享给大家。例如，我们要将响应状态码`401`、`403`和`404`归入一个分支，`400`和`405`归入到一个分支，其他保持不变，代码还可以这么写。 206 | 207 | ```python 208 | status_code = int(input('响应状态码: ')) 209 | match status_code: 210 | case 400 | 405: description = 'Invalid Request' 211 | case 401 | 403 | 404: description = 'Not Allowed' 212 | case _: description = 'Unknown Status Code' 213 | print('状态码描述:', description) 214 | ``` 215 | 216 | 运行结果： 217 | 218 | ``` 219 | 响应状态码: 403 220 | 状态码描述: Not Allowed 221 | ``` 222 | 223 | ### 分支结构应用举例 224 | 225 | #### 例子1：分段函数求值 226 | 227 | 有如下所示的分段函数，要求输入`x`，计算出`y`。 228 | $$ 229 | y = \begin{cases} 3x - 5, & (x \gt 1) \\ x + 2, & (-1 \le x \le 1) \\ 5x + 3, & (x \lt -1) \end{cases} 230 | $$ 231 | 232 | ```python 233 | """ 234 | 分段函数求值 235 | 236 | Version: 1.0 237 | Author: 骆昊 238 | """ 239 | x = float(input('x = ')) 240 | if x > 1: 241 | y = 3 * x - 5 242 | elif x >= -1: 243 | y = x + 2 244 | else: 245 | y = 5 * x + 3 246 | print(f'{y = }') 247 | ``` 248 | 249 | 根据实际开发的需要，分支结构是可以嵌套的，也就是说在分支结构的`if`、`elif`或`else`代码块中还可以再次引入分支结构。例如`if`条件成立表示玩家过关，但过关以后还要根据你获得宝物或者道具的数量对你的表现给出评价（比如点亮一颗、两颗或三颗星星），那么我们就需要在`if`的内部再构造一个新的分支结构。同理，我们在`elif`和`else`中也可以构造新的分支，我们称之为嵌套的分支结构。按照这样的思路，上面的分段函数求值也可以用下面的代码来实现。 250 | 251 | ```python 252 | """ 253 | 分段函数求值 254 | 255 | Version: 1.1 256 | Author: 骆昊 257 | """ 258 | x = float(input('x = ')) 259 | if x > 1: 260 | y = 3 * x - 5 261 | else: 262 | if x >= -1: 263 | y = x + 2 264 | else: 265 | y = 5 * x + 3 266 | print(f'{y = }') 267 | ``` 268 | 269 | > **说明**：大家可以自己感受和评判一下上面两种写法哪一种更好。在[**Python之禅**](https://zhuanlan.zhihu.com/p/111843067)中有这么一句话：“**Flat is better than nested**”。之所以认为“扁平化”的代码更好，是因为代码嵌套的层次如果很多，会严重的影响代码的可读性。所以，我认为上面的代码第一种写法是更好的选择。 270 | 271 | #### 例子2：百分制成绩转换为等级制成绩 272 | 273 | 要求：如果输入的成绩在90分以上（含90分），则输出`A`；输入的成绩在80分到90分之间（不含90分），则输出`B`；输入的成绩在70分到80分之间（不含80分），则输出`C`；输入的成绩在60分到70分之间（不含70分），则输出`D`；输入的成绩在60分以下，则输出`E`。 274 | 275 | ```python 276 | """ 277 | 百分制成绩转换为等级制成绩 278 | 279 | Version: 1.0 280 | Author: 骆昊 281 | """ 282 | score = float(input('请输入成绩: ')) 283 | if score >= 90: 284 | grade = 'A' 285 | elif score >= 80: 286 | grade = 'B' 287 | elif score >= 70: 288 | grade = 'C' 289 | elif score >= 60: 290 | grade = 'D' 291 | else: 292 | grade = 'E' 293 | print(f'{grade = }') 294 | ``` 295 | #### 例子3：计算三角形的周长和面积。 296 | 297 | 要求：输入三条边的长度，如果能构成三角形就计算周长和面积；否则给出“不能构成三角形”的提示。 298 | 299 | ```python 300 | """ 301 | 计算三角形的周长和面积 302 | 303 | Version: 1.0 304 | Author: 骆昊 305 | """ 306 | a = float(input('a = ')) 307 | b = float(input('b = ')) 308 | c = float(input('c = ')) 309 | if a + b > c and a + c > b and b + c > a: 310 | perimeter = a + b + c 311 | print(f'周长: {perimeter}') 312 | s = perimeter / 2 313 | area = (s * (s - a) * (s - b) * (s - c)) ** 0.5 314 | print(f'面积: {area}') 315 | else: 316 | print('不能构成三角形') 317 | ``` 318 | > **说明：** 上面的`if` 条件表示任意两边之和大于第三边，这是构成三角形的必要条件。当这个条件成立时，我们要计算并输出周长和面积，所以`if`下方有五条语句都保持了相同的缩进，它们是一个整体，只要`if`条件成立，它们都会被执行，这就是我们之前提到的代码块的概念。另外，上面计算三角形面积的公式叫做海伦公式，假设有一个三角形，边长分别为$\small{a}$、$\small{b}$、$\small{c}$，那么三角的面积$\small{A}$可以由下面的公式得到，其中，$\small{s=\frac{a+b+c}{2}}$。 319 | >$$ 320 | > A = \sqrt{s(s-a)(s-b)(s-c)} 321 | > $$ 322 | > 323 | 324 | ### 总结 325 | 326 | 学会了 Python 中的分支结构和循环结构，我们就可以解决很多实际的问题了。这一节课相信已经帮助大家掌握了构造分支结构的方法，下一节课我们为大家介绍循环结构，学完这两次课你一定会发现，你能写出很多很有意思的代码，继续加油吧！ 327 | -------------------------------------------------------------------------------- /第06课：循环结构.md: -------------------------------------------------------------------------------- 1 | ## 第06课：循环结构 2 | 3 | 我们在写程序的时候，极有可能遇到需要重复执行某条指令或某些指令的场景，例如我们需要每隔1秒钟在屏幕上输出一次“hello, world”并持续输出一个小时。如下所示的代码可以完成一次这样的操作，如果要持续输出一个小时，我们就需要把这段代码写3600遍，你愿意这么做吗？ 4 | 5 | ```python 6 | import time 7 | 8 | print('hello, world') 9 | time.sleep(1) 10 | ``` 11 | 12 | > **说明**：Python 内置`time`模块的`sleep`函数可以实现程序的休眠，参数`1`表示休眠的秒数，可以使用`int`或`float`类型，例如`0.05`表示`50`毫秒。 13 | 14 | 为了应对上述场景，我们可以在 Python 程序中使用循环结构。所谓循环结构，就是程序中控制某条或某些指令重复执行的结构。有了这样的结构，刚才的代码就不需要写3600遍，而是写一遍然后放到循环结构中重复3600次。在 Python 语言中构造循环结构有两种做法，一种是`for-in`循环，另一种是`while`循环。 15 | 16 | ### for-in循环 17 | 18 | 如果明确知道循环执行的次数，我们推荐使用`for-in`循环，例如上面说的那个重复3600次的场景，我们可以用下面的代码来实现。 注意，被`for-in`循环控制的代码块也是通过缩进的方式来构造，这一点跟分支结构中构造代码块的做法是一样的。我们被`for-in`循环控制的代码块称为循环体，通常循环体中的语句会根据循环的设定被重复执行。 19 | 20 | ```python 21 | """ 22 | 每隔1秒输出一次“hello, world”，持续1小时 23 | 24 | Author: 骆昊 25 | Version: 1.0 26 | """ 27 | import time 28 | 29 | for i in range(3600): 30 | print('hello, world') 31 | time.sleep(1) 32 | ``` 33 | 34 | 需要说明的是，上面代码中的`range(3600)`可以构造出一个从`0`到`3599`的范围，当我们把这样一个范围放到`for-in`循环中，就可以通过前面的循环变量`i`依次取出从`0`到`3599`的整数，这就让`for-in`代码块中的语句可以重复3600次。当然，`range`的用法非常灵活，下面的清单给出了使用`range`函数的例子： 35 | 36 | - `range(101)`：可以用来产生`0`到`100`范围的整数，需要注意的是取不到`101`。 37 | - `range(1, 101)`：可以用来产生`1`到`100`范围的整数，相当于是左闭右开的设定，即`[1, 101)`。 38 | - `range(1, 101, 2)`：可以用来产生`1`到`100`的奇数，其中`2`是步长（跨度），即每次递增的值，`101`取不到。 39 | - `range(100, 0, -2)`：可以用来产生`100`到`1`的偶数，其中`-2`是步长（跨度），即每次递减的值，`0`取不到。 40 | 41 | 大家可能已经注意到了，上面的输出和休眠操作都没有用到循环变量`i`，对于不需要用到循环变量的`for-in`循环结构，按照 Python 的编程惯例，我们通常把循环变量命名为`_`，修改后的代码如下所示。虽然结果没什么变化，但是这样写显得你更专业。 42 | 43 | ```python 44 | """ 45 | 每隔1秒输出一次“hello, world”，持续1小时 46 | 47 | Author: 骆昊 48 | Version: 1.1 49 | """ 50 | import time 51 | 52 | for _ in range(3600): 53 | print('hello, world') 54 | time.sleep(1) 55 | ``` 56 | 57 | 上面的代码要执行一个小时，如果想提前结束程序，在 PyCharm 中可以点击运行窗口上的停止按钮，如下图所示。如果在命令提示符或终端中运行代码，可以使用组合键`ctrl+c`来终止程序。 58 | 59 | 60 | 61 | 下面，我们用`for-in`循环实现从1到100的整数求和，即$\small{\sum_{n=1}^{100}n}$。 62 | 63 | ```python 64 | """ 65 | 从1到100的整数求和 66 | 67 | Version: 1.0 68 | Author: 骆昊 69 | """ 70 | total = 0 71 | for i in range(1, 101): 72 | total += i 73 | print(total) 74 | ``` 75 | 76 | 上面的代码中，变量`total`的作用是保存累加的结果。在循环的过程中，循环变量`i`的值会从`1`一直取到`100`。对于变量`i`的每个取值，我们都执行了`total += i`，它相当于`total = total + i`，这条语句实现了累加操作。所以，当循环结束，我们输出变量`total` 的值，它的值就是从`1`累加到`100`的结果`5050`。注意，`print(total)`这条语句前是没有缩进的，它不受`for-in`循环的控制，不会重复执行。 77 | 78 | 我们再来写一个从1到100偶数求和的代码，如下所示。 79 | 80 | ```python 81 | """ 82 | 从1到100的偶数求和 83 | 84 | Version: 1.0 85 | Author: 骆昊 86 | """ 87 | total = 0 88 | for i in range(1, 101): 89 | if i % 2 == 0: 90 | total += i 91 | print(total) 92 | ``` 93 | 94 | > **说明**：上面的`for-in`循环中我们使用了分支结构来判断循环变量`i`是不是偶数。 95 | 96 | 我们也可以修改`range`函数的参数，将起始值和跨度修改为`2`，用更为简单的代码实现从1到100的偶数求和。 97 | 98 | ```python 99 | """ 100 | 从1到100的偶数求和 101 | 102 | Version: 1.1 103 | Author: 骆昊 104 | """ 105 | total = 0 106 | for i in range(2, 101, 2): 107 | total += i 108 | print(total) 109 | ``` 110 | 111 | 当然， 更为简单的办法是使用 Python 内置的`sum`函数求和，这样我们连循环结构都省掉了。 112 | 113 | ```python 114 | """ 115 | 从1到100的偶数求和 116 | 117 | Version: 1.2 118 | Author: 骆昊 119 | """ 120 | print(sum(range(2, 101, 2))) 121 | ``` 122 | 123 | ### while循环 124 | 125 | 如果要构造循环结构但是又不能确定循环重复的次数，我们推荐使用`while`循环。`while`循环通过布尔值或能产生布尔值的表达式来控制循环，当布尔值或表达式的值为`True`时，循环体（`while`语句下方保持相同缩进的代码块）中的语句就会被重复执行，当表达式的值为`False`时，结束循环。 126 | 127 | 下面我们用`while`循环来实现从1到100的整数求和，代码如下所示。 128 | 129 | ```python 130 | """ 131 | 从1到100的整数求和 132 | 133 | Version: 1.1 134 | Author: 骆昊 135 | """ 136 | total = 0 137 | i = 1 138 | while i <= 100: 139 | total += i 140 | i += 1 141 | print(total) 142 | ``` 143 | 144 | 相较于`for-in`循环，上面的代码我们在循环开始前增加了一个变量`i`，我们使用这个变量来控制循环，所以`while`后面给出了`i <= 100`的条件。在`while`的循环体中，我们除了做累加，还需要让变量`i`的值递增，所以我们添加了`i += 1`这条语句，这样`i`的值就会依次取到`1`、`2`、`3`、……，直到`101`。当`i`变成`101`时，`while`循环的条件不再成立，代码会离开`while`循环，此时我们输出变量`total`的值，它就是从`1`到`100`求和的结果`5050`。 145 | 146 | 如果要实现从1到100的偶数求和，我们可以对上面的代码稍作修改。 147 | 148 | ```python 149 | """ 150 | 从1到100的偶数求和 151 | 152 | Version: 1.3 153 | Author: 骆昊 154 | """ 155 | total = 0 156 | i = 2 157 | while i <= 100: 158 | total += i 159 | i += 2 160 | print(total) 161 | ``` 162 | 163 | ### break和continue 164 | 165 | 我们再来看一个极端的场景，把`while`循环的条件直接设置为布尔值`True`，还是从1到100的偶数求和。 166 | 167 | ```python 168 | """ 169 | 从1到100的偶数求和 170 | 171 | Version: 1.4 172 | Author: 骆昊 173 | """ 174 | total = 0 175 | i = 2 176 | while True: 177 | total += i 178 | i += 2 179 | if i > 100: 180 | break 181 | print(total) 182 | ``` 183 | 184 | 上面的代码中使用`while True`构造了一个条件恒成立的循环，也就意味着如果不做特殊处理，循环是不会结束的，这也就是常说的“死循环”。为了在`i`的值超过`100`后让循环停下来，我们使用了`break`关键字，它的作用是终止循环结构的执行。需要注意的是，`break`只能终止它所在的那个循环，这一点在使用嵌套循环结构时需要引起注意，后面我们会讲到什么是嵌套的循环结构。除了`break`之外，还有另一个在循环结构中可以使用的关键字`continue`，它可以用来放弃本次循环后续的代码直接让循环进入下一轮，代码如下所示。 185 | 186 | ```python 187 | """ 188 | 从1到100的偶数求和 189 | 190 | Version: 1.5 191 | Author: 骆昊 192 | """ 193 | total = 0 194 | for i in range(1, 101): 195 | if i % 2 != 0: 196 | continue 197 | total += i 198 | print(total) 199 | ``` 200 | 201 | > **说明**：上面的代码使用`continue`关键字跳过了`i`是奇数的情况，只有在`i`是偶数的前提下，才会执行到`total += i`。 202 | 203 | ### 嵌套的循环结构 204 | 205 | 和分支结构一样，循环结构也是可以嵌套的，也就是说在循环结构中还可以构造循环结构。下面的例子演示了如何通过嵌套的循环来输出一个乘法口诀表（九九表）。 206 | 207 | ```python 208 | """ 209 | 打印乘法口诀表 210 | 211 | Version: 1.0 212 | Author: 骆昊 213 | """ 214 | for i in range(1, 10): 215 | for j in range(1, i + 1): 216 | print(f'{i}×{j}={i * j}', end='\t') 217 | print() 218 | ``` 219 | 220 | 上面的代码中，`for-in`循环的循环体中又用到了`for-in`循环，外面的循环用来控制产生`i`行的输出，而里面的循环则用来控制在一行中输出`j`列。显然，里面的`for-in`循环的输出就是乘法口诀表中的一整行。所以在里面的循环完成时，我们用了一个`print()`来实现换行的效果，最后的输出如下所示。 221 | 222 | ``` 223 | 1×1=1 224 | 2×1=2 2×2=4 225 | 3×1=3 3×2=6 3×3=9 226 | 4×1=4 4×2=8 4×3=12 4×4=16 227 | 5×1=5 5×2=10 5×3=15 5×4=20 5×5=25 228 | 6×1=6 6×2=12 6×3=18 6×4=24 6×5=30 6×6=36 229 | 7×1=7 7×2=14 7×3=21 7×4=28 7×5=35 7×6=42 7×7=49 230 | 8×1=8 8×2=16 8×3=24 8×4=32 8×5=40 8×6=48 8×7=56 8×8=64 231 | 9×1=9 9×2=18 9×3=27 9×4=36 9×5=45 9×6=54 9×7=63 9×8=72 9×9=81 232 | ``` 233 | 234 | ### 循环结构应用举例 235 | 236 | #### 例子1：判断素数 237 | 238 | 要求：输入一个大于1的正整数，判断它是不是素数。 239 | 240 | > **提示**：素数指的是只能被1和自身整除的大于1的整数。例如对于正整数`n`，我们可以通过在`2`到`n-1`之间寻找有没有`n`的因子，来判断它到底是不是一个素数。当然，循环不用从`2`开始到`n-1`结束，因为对于大于1的正整数，因子应该都是成对出现的，所以循环到$\small{\sqrt{n}}$就可以结束了。 241 | 242 | ```python 243 | """ 244 | 输入一个大于1的正整数判断它是不是素数 245 | 246 | Version: 1.0 247 | Author: 骆昊 248 | """ 249 | num = int(input('请输入一个正整数: ')) 250 | end = int(num ** 0.5) 251 | is_prime = True 252 | for i in range(2, end + 1): 253 | if num % i == 0: 254 | is_prime = False 255 | break 256 | if is_prime: 257 | print(f'{num}是素数') 258 | else: 259 | print(f'{num}不是素数') 260 | ``` 261 | 262 | > **说明**：上面的代码中我们用了布尔型的变量`is_prime`，我们先将它赋值为`True`，假设`num`是一个素数；接下来，我们在`2`到`num ** 0.5`的范围寻找`num`的因子，如果找到了`num`的因子，那么它一定不是素数，此时我们将`is_prime`赋值为`False`，同时使用`break`关键字终止循环结构；最后，我们根据`is_prime`的值是`True`还是`False`来给出不同的输出。 263 | 264 | #### 例子2：最大公约数 265 | 266 | 要求：输入两个大于`0`的正整数，求两个数的最大公约数。 267 | 268 | > **提示**：两个数的最大公约数是两个数的公共因子中最大的那个数。 269 | 270 | ```python 271 | """ 272 | 输入两个正整数求它们的最大公约数 273 | 274 | Version: 1.0 275 | Author: 骆昊 276 | """ 277 | x = int(input('x = ')) 278 | y = int(input('y = ')) 279 | for i in range(x, 0, -1): 280 | if x % i == 0 and y % i == 0: 281 | print(f'最大公约数: {i}') 282 | break 283 | ``` 284 | 285 | > **说明**：上面代码中`for-in`循环的循环变量值是从大到小的，这样我们找到的能够同时整除`x`和`y`的因子`i`，就是`x`和`y`的最大公约数，此时我们用`break`终止循环。如果`x`和`y`互质，那么循环会执行到`i`变成`1`，因为`1`是所有正整数的因子，此时`x`和`y`的最大公约数就是`1`。 286 | 287 | 用上面代码的找最大公约数在执行效率是有问题的。假如`x`的值是`999999999998`，`y`的值是`999999999999`，很显然两个数是互质的，最大公约数为`1`。但是我们使用上面的代码，循环会重复`999999999998`次，这通常是难以接受的。我们可以使用欧几里得算法（辗转相除法）来找最大公约数，它能帮我们更快的得到想要的结果，代码如下所示。 288 | 289 | ```python 290 | """ 291 | 输入两个正整数求它们的最大公约数 292 | 293 | Version: 1.1 294 | Author: 骆昊 295 | """ 296 | x = int(input('x = ')) 297 | y = int(input('y = ')) 298 | while y % x != 0: 299 | x, y = y % x, x 300 | print(f'最大公约数: {x}') 301 | ``` 302 | 303 | > **说明**：解决问题的方法和步骤可以称之为算法，对于同一个问题，我们可以设计出不同的算法，不同的算法在存储空间的占用和执行效率上都会存在差别，而这些差别就代表了算法的优劣。大家可以对比上面的两段待会，体会一下为什么我们说欧几里得算法是更好的选择。上面的代码中`x, y = y % x, x`语句表示将`y % x`的值赋给`x`，将`x` 原来的值赋给`y`。 304 | 305 | #### 例子3：猜数字小游戏 306 | 307 | 要求：计算机出一个`1`到`100`之间的随机数，玩家输入自己猜的数字，计算机给出对应的提示信息“大一点”、“小一点”或“猜对了”，如果玩家猜中了数字，计算机提示用户一共猜了多少次，游戏结束，否则游戏继续。 308 | 309 | ```python 310 | """ 311 | 猜数字小游戏 312 | 313 | Version: 1.0 314 | Author: 骆昊 315 | """ 316 | import random 317 | 318 | answer = random.randrange(1, 101) 319 | counter = 0 320 | while True: 321 | counter += 1 322 | num = int(input('请输入: ')) 323 | if num < answer: 324 | print('大一点.') 325 | elif num > answer: 326 | print('小一点.') 327 | else: 328 | print('猜对了.') 329 | break 330 | print(f'你一共猜了{counter}次.') 331 | ``` 332 | 333 | > **说明**：上面的代码使用`import random`导入了 Python 标准库的`random`模块，该模块的`randrange`函数帮助我们生成了`1`到`100`范围的随机数。变量`counter`用来记录循环执行的次数，也就是用户一共做出了几次猜测，每循环一次`counter`的值都会加`1`。 334 | 335 | ### 总结 336 | 337 | 学会了 Python 中的分支结构和循环结构，我们就可以解决很多实际的问题了。通过这节课的学习，大家应该已经知道了可以用`for`和`while`关键字来构造循环结构。**如果事先知道循环结构重复的次数，我们通常使用`for`循环**；**如果循环结构的重复次数不能确定，可以用`while`循环**。此外，我们可以在循环结构中**使用`break`终止循环**，也可以在循环结构中**使用`continue`关键字让循环结构直接进入下一轮次**。 338 | -------------------------------------------------------------------------------- /第07课：分支和循环结构的应用.md: -------------------------------------------------------------------------------- 1 | ## 第07课：分支结构和循环结构的应用 2 | 3 | 通过前面两节课的学习，大家对 Python 中的分支结构和循环结构已经有了初步的认知。**分支结构和循环结构是构造程序逻辑的基础**，它们的重要性不言而喻，但是对于初学者来说这也是比较困难的部分。很多人对分支结构和循环结构的语法是能够理解的，但是遇到实际问题的时候又无法下手；**看懂别人的代码很容易，但是要自己写出类似的代码却又很难**。如果你也有同样的问题和困惑，千万不要沮丧，这只是因为你的编程之旅才刚刚开始，**你的练习量还没有达到让你可以随心所欲的写出代码的程度**，只要加强编程练习，通过量的积累来产生质的变化，这个问题迟早都会解决的。 4 | 5 | ### 经典小案例 6 | 7 | #### 例子1：100以内的素数 8 | 9 | > **说明**：素数指的是只能被1和自身整除的正整数（不包括1），之前我们写过判断素数的代码，这里相当于是一个升级版本。 10 | 11 | ```Python 12 | """ 13 | 输出100以内的素数 14 | 15 | Version: 1.0 16 | Author: 骆昊 17 | """ 18 | for num in range(2, 100): 19 | is_prime = True 20 | for i in range(2, int(num ** 0.5) + 1): 21 | if num % i == 0: 22 | is_prime = False 23 | break 24 | if is_prime: 25 | print(num) 26 | ``` 27 | 28 | #### 例子2：斐波那契数列 29 | 30 | 要求：输出斐波那契数列中的前20个数。 31 | 32 | > **说明**：斐波那契数列（Fibonacci sequence），通常也被称作黄金分割数列，是意大利数学家莱昂纳多·斐波那契（Leonardoda Fibonacci）在《计算之书》中研究理想假设条件下兔子成长率问题而引入的数列，因此这个数列也常被戏称为“兔子数列”。斐波那契数列的特点是数列的前两个数都是1，从第三个数开始，每个数都是它前面两个数的和。按照这个规律，斐波那契数列的前10个数是：`1, 1, 2, 3, 5, 8, 13, 21, 34, 55`。斐波那契数列在现代物理、准晶体结构、化学等领域都有直接的应用。 33 | 34 | ```Python 35 | """ 36 | 输出斐波那契数列中的前20个数 37 | 38 | Version: 1.0 39 | Author: 骆昊 40 | """ 41 | 42 | a, b = 0, 1 43 | for _ in range(20): 44 | a, b = b, a + b 45 | print(a) 46 | ``` 47 | 48 | > **说明**：上面循环中的`a, b = b, a + b`表示将变量`b`的值赋给`a`，把`a + b`的值赋给`b`。通过这个递推公式，我们可以依次获得斐波那契数列中的数。 49 | 50 | #### 例子3：寻找水仙花数 51 | 52 | 要求：找出`100`到`999`范围内的所有水仙花数。 53 | 54 | > **提示**：在数论中，水仙花数（narcissistic number）也被称为超完全数字不变数、自恋数、自幂数、阿姆斯特朗数，它是一个$\small{N}$位非负整数，其各位数字的$\small{N}$次方和刚好等于该数本身，例如：$\small{153=1^3+5^3+3^3}$，所以`153` 是一个水仙花数；$\small{1634=1^4+6^4+3^4+4^4}$，所以`1634`也是一个水仙花数。对于三位数，解题的关键是将它拆分为个位、十位、百位，再判断是否满足水仙花数的要求，这一点利用Python中的`//`和`%`运算符其实很容易做到。 55 | 56 | ```python 57 | """ 58 | 找出100到999范围内的水仙花数 59 | 60 | Version: 1.0 61 | Author: 骆昊 62 | """ 63 | for num in range(100, 1000): 64 | low = num % 10 65 | mid = num // 10 % 10 66 | high = num // 100 67 | if num == low ** 3 + mid ** 3 + high ** 3: 68 | print(num) 69 | ``` 70 | 71 | 上面利用`//`和`%`拆分一个数的小技巧在写代码的时候还是很常用的。我们要将一个不知道有多少位的正整数进行反转，例如将`12389`变成`98321`，也可以利用这两个运算来实现，代码如下所示。 72 | 73 | ```python 74 | """ 75 | 正整数的反转 76 | 77 | Version: 1.0 78 | Author: 骆昊 79 | """ 80 | num = int(input('num = ')) 81 | reversed_num = 0 82 | while num > 0: 83 | reversed_num = reversed_num * 10 + num % 10 84 | num //= 10 85 | print(reversed_num) 86 | ``` 87 | 88 | #### 例子4：百钱百鸡问题 89 | 90 | > **说明**：百钱百鸡是我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？翻译成现代文是：公鸡5元一只，母鸡3元一只，小鸡1元三只，用100块钱买一百只鸡，问公鸡、母鸡、小鸡各有多少只？ 91 | 92 | ```python 93 | """ 94 | 百钱百鸡问题 95 | 96 | Version: 1.0 97 | Author: 骆昊 98 | """ 99 | for x in range(0, 21): 100 | for y in range(0, 34): 101 | for z in range(0, 100, 3): 102 | if x + y + z == 100 and 5 * x + 3 * y + z // 3 == 100: 103 | print(f'公鸡: {x}只, 母鸡: {y}只, 小鸡: {z}只') 104 | ``` 105 | 106 | 上面使用的方法叫做**穷举法**，也称为**暴力搜索法**，这种方法通过一项一项的列举备选解决方案中所有可能的候选项，并检查每个候选项是否符合问题的描述，最终得到问题的解。上面的代码中，我们使用了嵌套的循环结构，假设公鸡有`x`只，显然`x`的取值范围是0到20，假设母鸡有`y`只，它的取值范围是`0`到`33`，假设小鸡有`z`只，它的取值范围是`0`到`99`且取值是`3` 的倍数。这样，我们设置好`100`只鸡的条件`x + y + z == 100`，设置好`100`块钱的条件`5 * x + 3 * y + z // 3 == 100`，当两个条件同时满足时，就是问题的正确答案，我们用`print`函数输出它。这种方法看起来比较笨拙，但对于运算能力非常强大的计算机来说，通常都是一个可行的甚至是不错的选择，只要问题的解存在就能够找到它。 107 | 108 | 事实上，上面的代码还有更好的写法，既然我们已经假设公鸡有`x`只，母鸡有`y`只，那么小鸡的数量就应该是`100 - x - y`，这样减少一个条件，我们就可以把上面三层嵌套的`for-in`循环改写为两层嵌套的`for-in`循环。循环次数减少了，代码的执行效率就有了显著的提升，如下所示。 109 | 110 | ```python 111 | """ 112 | 百钱百鸡问题 113 | 114 | Version: 1.1 115 | Author: 骆昊 116 | """ 117 | for x in range(0, 21): 118 | for y in range(0, 34): 119 | z = 100 - x - y 120 | if z % 3 == 0 and 5 * x + 3 * y + z // 3 == 100: 121 | print(f'公鸡: {x}只, 母鸡: {y}只, 小鸡: {z}只') 122 | ``` 123 | 124 | > **说明**：上面代码中的`z % 3 == 0`是为了确保小鸡的数量是`3`的倍数。 125 | 126 | #### 例子5：CRAPS赌博游戏 127 | 128 | > **说明**：CRAPS又称花旗骰，是美国拉斯维加斯非常受欢迎的一种的桌上赌博游戏。该游戏使用两粒骰子，玩家通过摇两粒骰子获得点数进行游戏。简化后的规则是：玩家第一次摇骰子如果摇出了`7`点或`11`点，玩家胜；玩家第一次如果摇出`2`点、`3`点或`12`点，庄家胜；玩家如果摇出其他点数则游戏继续，玩家重新摇骰子，如果玩家摇出了`7`点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数玩家继续摇骰子，直到分出胜负。为了增加代码的趣味性，我们设定游戏开始时玩家有`1000`元的赌注，每局游戏开始之前，玩家先下注，如果玩家获胜就可以获得对应下注金额的奖励，如果庄家获胜，玩家就会输掉自己下注的金额。游戏结束的条件是玩家破产（输光所有的赌注）。 129 | 130 | ```Python 131 | """ 132 | Craps赌博游戏 133 | 134 | Version: 1.0 135 | Author: 骆昊 136 | """ 137 | import random 138 | 139 | money = 1000 140 | while money > 0: 141 | print(f'你的总资产为: {money}元') 142 | # 下注金额必须大于0且小于等于玩家的总资产 143 | while True: 144 | debt = int(input('请下注: ')) 145 | if 0 < debt <= money: 146 | break 147 | # 用两个1到6均匀分布的随机数相加模拟摇两颗色子得到的点数 148 | first_point = random.randrange(1, 7) + random.randrange(1, 7) 149 | print(f'\n玩家摇出了{first_point}点') 150 | if first_point == 7 or first_point == 11: 151 | print('玩家胜!\n') 152 | money += debt 153 | elif first_point == 2 or first_point == 3 or first_point == 12: 154 | print('庄家胜!\n') 155 | money -= debt 156 | else: 157 | # 如果第一次摇色子没有分出胜负，玩家需要重新摇色子 158 | while True: 159 | current_point = random.randrange(1, 7) + random.randrange(1, 7) 160 | print(f'玩家摇出了{current_point}点') 161 | if current_point == 7: 162 | print('庄家胜!\n') 163 | money -= debt 164 | break 165 | elif current_point == first_point: 166 | print('玩家胜!\n') 167 | money += debt 168 | break 169 | print('你破产了, 游戏结束!') 170 | ``` 171 | 172 | ### 总结 173 | 174 | 分支结构和循环结构都非常重要，是构造程序逻辑的基础，**一定要通过大量的练习来达到融会贯通**。我们可以用上面讲的花旗骰游戏作为一个标准，如果你能够很顺利的完成这段代码，那么分支结构和循环结构的知识你就已经很好的掌握了。 175 | 176 | -------------------------------------------------------------------------------- /第08课：常用数据结构之列表-1.md: -------------------------------------------------------------------------------- 1 | ## 第08课：常用数据结构之列表-1 2 | 3 | 在开始本节课的内容之前，我们先给大家一个编程任务，将一颗色子掷`6000`次，统计每种点数出现的次数。这个任务对大家来说应该是非常简单的，我们可以用`1`到`6`均匀分布的随机数来模拟掷色子，然后用`6`个变量分别记录每个点数出现的次数，相信通过前面的学习，大家都能比较顺利的写出下面的代码。 4 | 5 | ```python 6 | """ 7 | 将一颗色子掷6000次，统计每种点数出现的次数 8 | 9 | Author: 骆昊 10 | Version: 1.0 11 | """ 12 | import random 13 | 14 | f1 = 0 15 | f2 = 0 16 | f3 = 0 17 | f4 = 0 18 | f5 = 0 19 | f6 = 0 20 | for _ in range(6000): 21 | face = random.randrange(1, 7) 22 | if face == 1: 23 | f1 += 1 24 | elif face == 2: 25 | f2 += 1 26 | elif face == 3: 27 | f3 += 1 28 | elif face == 4: 29 | f4 += 1 30 | elif face == 5: 31 | f5 += 1 32 | else: 33 | f6 += 1 34 | print(f'1点出现了{f1}次') 35 | print(f'2点出现了{f2}次') 36 | print(f'3点出现了{f3}次') 37 | print(f'4点出现了{f4}次') 38 | print(f'5点出现了{f5}次') 39 | print(f'6点出现了{f6}次') 40 | ``` 41 | 42 | 上面的代码非常有多么“丑陋”相信就不用我多说了。当然，更为可怕的是，如果我们要掷两颗或者掷更多的色子，然后统计每种点数出现的次数，那就需要定义更多的变量，写更多的分支结构，大家想想都会感到恶心。讲到这里，相信大家心中已经有一个疑问了：有没有办法用一个变量来保存多个数据，有没有办法用统一的代码对多个数据进行操作？答案是肯定的，在 Python 中我们可以通过容器类型的变量来保存和操作多个数据，我们首先为大家介绍列表（`list`）这种新的数据类型。 43 | 44 | ### 创建列表 45 | 46 | 在 Python 中，**列表是由一系元素按特定顺序构成的数据序列**，这就意味着如果我们定义一个列表类型的变量，**可以用它来保存多个数据**。在 python 中，可以使用`[]`字面量语法来定义列表，列表中的多个元素用逗号进行分隔，代码如下所示。 47 | 48 | ```python 49 | items1 = [35, 12, 99, 68, 55, 35, 87] 50 | items2 = ['Python', 'Java', 'Go', 'Kotlin'] 51 | items3 = [100, 12.3, 'Python', True] 52 | print(items1) # [35, 12, 99, 68, 55, 35, 87] 53 | print(items2) # ['Python', 'Java', 'Go', 'Kotlin'] 54 | print(items3) # [100, 12.3, 'Python', True] 55 | ``` 56 | 57 | > **说明**：列表中可以有重复元素，例如`items1`中的`35`；列表中可以有不同类型的元素，例如`items3`中有`int`类型、`float`类型、`str`类型和`bool`类型的元素，但是我们通常并不建议将不同类型的元素放在同一个列表中，主要是操作起来极为不方便。 58 | 59 | 我们可以使用`type`函数来查看变量的类型，有兴趣的小伙伴可以自行查看上面的变量`items1`到底是什么类型。因为列表可以保存多个元素，它是一种容器型的数据类型，所以我们在给列表类型的变量起名字时，变量名通常用复数形式的单词。 60 | 61 | 除此以外，还可以通过 Python 内置的`list`函数将其他序列变成列表。准确的说，`list`并不是一个普通的函数，它是创建列表对象的构造器，后面的课程会为大家介绍对象和构造器这些概念。 62 | 63 | ```python 64 | items4 = list(range(1, 10)) 65 | items5 = list('hello') 66 | print(items4) # [1, 2, 3, 4, 5, 6, 7, 8, 9] 67 | print(items5) # ['h', 'e', 'l', 'l', 'o'] 68 | ``` 69 | 70 | > **说明**：`range(1, 10)`会产生`1`到`9`的整数序列，给到`list`构造器中，会创建出由`1`到`9`的整数构成的列表。字符串是字符构成的序列，上面的`list('hello')`用字符串`hello`的字符作为列表元素，创建了列表对象。 71 | 72 | ### 列表的运算 73 | 74 | 我们可以使用`+`运算符实现两个列表的拼接，拼接运算会将两个列表中的元素连接起来放到一个列表中，代码如下所示。 75 | 76 | ```python 77 | items5 = [35, 12, 99, 45, 66] 78 | items6 = [45, 58, 29] 79 | items7 = ['Python', 'Java', 'JavaScript'] 80 | print(items5 + items6) # [35, 12, 99, 45, 66, 45, 58, 29] 81 | print(items6 + items7) # [45, 58, 29, 'Python', 'Java', 'JavaScript'] 82 | items5 += items6 83 | print(items5) # [35, 12, 99, 45, 66, 45, 58, 29] 84 | ``` 85 | 86 | 我们可以使用`*`运算符实现列表的重复运算，`*`运算符会将列表元素重复指定的次数，我们在上面的代码中增加两行，如下所示。 87 | 88 | ```python 89 | print(items6 * 3) # [45, 58, 29, 45, 58, 29, 45, 58, 29] 90 | print(items7 * 2) # ['Python', 'Java', 'JavaScript', 'Python', 'Java', 'JavaScript'] 91 | ``` 92 | 93 | 我们可以使用`in`或`not in`运算符判断一个元素在不在列表中，我们在上面的代码代码中再增加两行，如下所示。 94 | 95 | ```python 96 | print(29 in items6) # True 97 | print(99 in items6) # False 98 | print('C++' not in items7) # True 99 | print('Python' not in items7) # False 100 | ``` 101 | 102 | 由于列表中有多个元素，而且元素是按照特定顺序放在列表中的，所以当我们想操作列表中的某个元素时，可以使用`[]`运算符，通过在`[]`中指定元素的位置来访问该元素，这种运算称为索引运算。需要说明的是，`[]`的元素位置可以是`0`到`N - 1`的整数，也可以是`-1`到`-N`的整数，分别称为正向索引和反向索引，其中`N`代表列表元素的个数。对于正向索引，`[0]`可以访问列表中的第一个元素，`[N - 1]`可以访问最后一个元素；对于反向索引，`[-1]`可以访问列表中的最后一个元素，`[-N]`可以访问第一个元素，代码如下所示。 103 | 104 | ```python 105 | items8 = ['apple', 'waxberry', 'pitaya', 'peach', 'watermelon'] 106 | print(items8[0]) # apple 107 | print(items8[2]) # pitaya 108 | print(items8[4]) # watermelon 109 | items8[2] = 'durian' 110 | print(items8) # ['apple', 'waxberry', 'durian', 'peach', 'watermelon'] 111 | print(items8[-5]) # 'apple' 112 | print(items8[-4]) # 'waxberry' 113 | print(items8[-1]) # watermelon 114 | items8[-4] = 'strawberry' 115 | print(items8) # ['apple', 'strawberry', 'durian', 'peach', 'watermelon'] 116 | ``` 117 | 118 | 在使用索引运算的时候要避免出现索引越界的情况，对于上面的`items8`，如果我们访问`items8[5]`或`items8[-6]`，就会引发`IndexError`错误，导致程序崩溃，对应的错误信息是：*list index out of range*，翻译成中文就是“数组索引超出范围”。因为对于只有五个元素的列表`items8`，有效的正向索引是`0`到`4`，有效的反向索引是`-1`到`-5`。 119 | 120 | 如果希望一次性访问列表中的多个元素，我们可以使用切片运算。切片运算是形如`[start:end:stride]`的运算符，其中`start`代表访问列表元素的起始位置，`end`代表访问列表元素的终止位置（终止位置的元素无法访问），而`stride`则代表了跨度，简单的说就是位置的增量，比如我们访问的第一个元素在`start`位置，那么第二个元素就在`start + stride`位置，当然`start + stride`要小于`end`。我们给上面的代码增加下面的语句，来使用切片运算符访问列表元素。 121 | 122 | ```python 123 | print(items8[1:3:1]) # ['strawberry', 'durian'] 124 | print(items8[0:3:1]) # ['apple', 'strawberry', 'durian'] 125 | print(items8[0:5:2]) # ['apple', 'durian', 'watermelon'] 126 | print(items8[-4:-2:1]) # ['strawberry', 'durian'] 127 | print(items8[-2:-6:-1]) # ['peach', 'durian', 'strawberry', 'apple'] 128 | ``` 129 | 130 | > **提醒**：大家可以看看上面代码中的最后一行，想一想当跨度为负数时，切片运算是如何访问元素的。 131 | 132 | 如果`start`值等于`0`，那么在使用切片运算符时可以将其省略；如果`end`值等于`N`，`N`代表列表元素的个数，那么在使用切片运算符时可以将其省略；如果`stride`值等于`1`，那么在使用切片运算符时也可以将其省略。所以，下面的代码跟上面的代码作用完全相同。 133 | 134 | ```python 135 | print(items8[1:3]) # ['strawberry', 'durian'] 136 | print(items8[:3:1]) # ['apple', 'strawberry', 'durian'] 137 | print(items8[::2]) # ['apple', 'durian', 'watermelon'] 138 | print(items8[-4:-2]) # ['strawberry', 'durian'] 139 | print(items8[-2::-1]) # ['peach', 'durian', 'strawberry', 'apple'] 140 | ``` 141 | 142 | 事实上，我们还可以通过切片操作修改列表中的元素，例如我们给上面的代码再加上一行，大家可以看看这里的输出。 143 | 144 | ```python 145 | items8[1:3] = ['x', 'o'] 146 | print(items8) # ['apple', 'x', 'o', 'peach', 'watermelon'] 147 | ``` 148 | 149 | 两个列表还可以做关系运算，我们可以比较两个列表是否相等，也可以给两个列表比大小，代码如下所示。 150 | 151 | ```python 152 | nums1 = [1, 2, 3, 4] 153 | nums2 = list(range(1, 5)) 154 | nums3 = [3, 2, 1] 155 | print(nums1 == nums2) # True 156 | print(nums1 != nums2) # False 157 | print(nums1 <= nums3) # True 158 | print(nums2 >= nums3) # False 159 | ``` 160 | 161 | > **说明**：上面的`nums1`和`nums2`对应元素完全相同，所以`==`运算的结果是`True`。`nums2`和`nums3`的比较，由于`nums2`的第一个元素`1`小于`nums3`的第一个元素`3`，所以`nums2 >= nums3`比较的结果是`False`。两个列表的关系运算在实际工作并不那么常用，如果实在不理解就下面放放吧，不用纠结。 162 | 163 | ### 元素的遍历 164 | 165 | 如果想逐个取出列表中的元素，可以使用`for-in`循环的，有以下两种做法。 166 | 167 | 方法一：在循环结构中通过索引运算，遍历列表元素。 168 | 169 | ```python 170 | languages = ['Python', 'Java', 'C++', 'Kotlin'] 171 | for index in range(len(languages)): 172 | print(languages[index]) 173 | ``` 174 | 175 | 输出： 176 | 177 | ``` 178 | Python 179 | Java 180 | C++ 181 | Kotlin 182 | ``` 183 | 184 | > **说明**：上面的`len`函数可以获取列表元素的个数`N`，而`range(N)`则构成了从`0`到`N-1`的范围，刚好可以作为列表元素的索引。 185 | 186 | 方法二：直接对列表做循环，循环变量就是列表元素的代表。 187 | 188 | ```python 189 | languages = ['Python', 'Java', 'C++', 'Kotlin'] 190 | for language in languages: 191 | print(language) 192 | ``` 193 | 194 | 输出： 195 | 196 | ``` 197 | Python 198 | Java 199 | C++ 200 | Kotlin 201 | ``` 202 | 203 | ### 总结 204 | 205 | 讲到这里，我们可以用列表的知识来重构上面“掷色子统计每种点数出现次数”的代码。 206 | 207 | ```python 208 | """ 209 | 将一颗色子掷6000次，统计每种点数出现的次数 210 | 211 | Author: 骆昊 212 | Version: 1.1 213 | """ 214 | import random 215 | 216 | counters = [0] * 6 217 | # 模拟掷色子记录每种点数出现的次数 218 | for _ in range(6000): 219 | face = random.randrange(1, 7) 220 | counters[face - 1] += 1 221 | # 输出每种点数出现的次数 222 | for face in range(1, 7): 223 | print(f'{face}点出现了{counters[face - 1]}次') 224 | ``` 225 | 226 | 上面的代码中，我们用`counters`列表中的六个元素分别表示`1`到`6`点出现的次数，最开始的时候六个元素的值都是`0`。接下来，我们用`1`到`6`均匀分布的随机数模拟掷色子，如果摇出1点，`counters[0]`的值加`1`，如果摇出2点，`counters[1]`的值加`1`，以此类推。大家感受一下，由于使用了列表类型加上循环结构，我们对数据的处理是批量性的，这就使得修改后的代码比之前的代码要简单优雅得多。 227 | -------------------------------------------------------------------------------- /第09课：常用数据结构之列表-2.md: -------------------------------------------------------------------------------- 1 | ## 第09课：常用数据结构之列表-2 2 | 3 | ### 列表的方法 4 | 5 | 列表类型的变量拥有很多方法可以帮助我们操作一个列表，假设我们有名为`foos`的列表，列表有名为`bar`的方法，那么使用列表方法的语法是：`foos.bar()`，这是一种通过对象引用调用对象方法的语法。后面我们讲面向对象编程的时候，还会对这种语法进行详细的讲解，这种语法也称为给对象发消息。 6 | 7 | #### 添加和删除元素 8 | 9 | 列表是一种可变容器，可变容器指的是我们可以向容器中添加元素、可以从容器移除元素，也可以修改现有容器中的元素。我们可以使用列表的`append`方法向列表中追加元素，使用`insert`方法向列表中插入元素。追加指的是将元素添加到列表的末尾，而插入则是在指定的位置添加新元素，大家可以看看下面的代码。 10 | 11 | ```python 12 | languages = ['Python', 'Java', 'C++'] 13 | languages.append('JavaScript') 14 | print(languages) # ['Python', 'Java', 'C++', 'JavaScript'] 15 | languages.insert(1, 'SQL') 16 | print(languages) # ['Python', 'SQL', 'Java', 'C++', 'JavaScript'] 17 | ``` 18 | 19 | 我们可以用列表的`remove`方法从列表中删除指定元素，需要注意的是，如果要删除的元素并不在列表中，会引发`ValueError`错误导致程序崩溃，所以建议大家在删除元素时，先用之前讲过的成员运算做一个判断。我们还可以使用`pop`方法从列表中删除元素，`pop`方法默认删除列表中的最后一个元素，当然也可以给一个位置，删除指定位置的元素。在使用`pop`方法删除元素时，如果索引的值超出了范围，会引发`IndexError`异常，导致程序崩溃。除此之外，列表还有一个`clear`方法，可以清空列表中的元素，代码如下所示。 20 | 21 | ```python 22 | languages = ['Python', 'SQL', 'Java', 'C++', 'JavaScript'] 23 | if 'Java' in languages: 24 | languages.remove('Java') 25 | if 'Swift' in languages: 26 | languages.remove('Swift') 27 | print(languages) # ['Python', 'SQL', C++', 'JavaScript'] 28 | languages.pop() 29 | temp = languages.pop(1) 30 | print(temp) # SQL 31 | languages.append(temp) 32 | print(languages) # ['Python', C++', 'SQL'] 33 | languages.clear() 34 | print(languages) # [] 35 | ``` 36 | 37 | > **说明**：`pop`方法删除元素时会得到被删除的元素，上面的代码中，我们将`pop`方法删除的元素赋值给了名为`temp`的变量。当然如果你愿意，还可以把这个元素再次加入到列表中，正如上面的代码`languages.append(temp)`所做的那样。 38 | 39 | 这里还有一个小问题，例如`languages`列表中有多个`'Python'`，那么我们用`languages.remove('Python')`是删除所有的`'Python'`，还是删除第一个`'Python'`，大家可以先猜一猜，然后再自己动手尝试一下。 40 | 41 | 从列表中删除元素其实还有一种方式，就是使用 Python 中的`del`关键字后面跟要删除的元素，这种做法跟使用`pop`方法指定索引删除元素没有实质性的区别，但后者会返回删除的元素，前者在性能上略优，因为`del`对应的底层字节码指令是`DELETE_SUBSCR`，而`pop`对应的底层字节码指令是`CALL_METHOD`和`POP_TOP`，如果不理解就不用管它了。 42 | 43 | ```python 44 | items = ['Python', 'Java', 'C++'] 45 | del items[1] 46 | print(items) # ['Python', 'C++'] 47 | ``` 48 | 49 | #### 元素位置和频次 50 | 51 | 列表的`index`方法可以查找某个元素在列表中的索引位置，如果找不到指定的元素，`index`方法会引发`ValueError`错误；列表的`count`方法可以统计一个元素在列表中出现的次数，代码如下所示。 52 | 53 | ```python 54 | items = ['Python', 'Java', 'Java', 'C++', 'Kotlin', 'Python'] 55 | print(items.index('Python')) # 0 56 | # 从索引位置1开始查找'Python' 57 | print(items.index('Python', 1)) # 5 58 | print(items.count('Python')) # 2 59 | print(items.count('Kotlin')) # 1 60 | print(items.count('Swfit')) # 0 61 | # 从索引位置3开始查找'Java' 62 | print(items.index('Java', 3)) # ValueError: 'Java' is not in list 63 | ``` 64 | 65 | #### 元素排序和反转 66 | 67 | 列表的`sort`操作可以实现列表元素的排序，而`reverse`操作可以实现元素的反转，代码如下所示。 68 | 69 | ```python 70 | items = ['Python', 'Java', 'C++', 'Kotlin', 'Swift'] 71 | items.sort() 72 | print(items) # ['C++', 'Java', 'Kotlin', 'Python', 'Swift'] 73 | items.reverse() 74 | print(items) # ['Swift', 'Python', 'Kotlin', 'Java', 'C++'] 75 | ``` 76 | 77 | ### 列表生成式 78 | 79 | 在 Python 中，列表还可以通过一种特殊的字面量语法来创建，这种语法叫做生成式。下面，我们通过例子来说明使用列表生成式创建列表到底有什么好处。 80 | 81 | 场景一：创建一个取值范围在`1`到`99`且能被`3`或者`5`整除的数字构成的列表。 82 | 83 | ```python 84 | items = [] 85 | for i in range(1, 100): 86 | if i % 3 == 0 or i % 5 == 0: 87 | items.append(i) 88 | print(items) 89 | ``` 90 | 91 | 使用列表生成式做同样的事情，代码如下所示。 92 | 93 | ```python 94 | items = [i for i in range(1, 100) if i % 3 == 0 or i % 5 == 0] 95 | print(items) 96 | ``` 97 | 98 | 场景二：有一个整数列表`nums1`，创建一个新的列表`nums2`，`nums2`中的元素是`nums1`中对应元素的平方。 99 | 100 | ```python 101 | nums1 = [35, 12, 97, 64, 55] 102 | nums2 = [] 103 | for num in nums1: 104 | nums2.append(num ** 2) 105 | print(nums2) 106 | ``` 107 | 108 | 使用列表生成式做同样的事情，代码如下所示。 109 | 110 | ```python 111 | nums1 = [35, 12, 97, 64, 55] 112 | nums2 = [num ** 2 for num in nums1] 113 | print(nums2) 114 | ``` 115 | 116 | 场景三： 有一个整数列表`nums1`，创建一个新的列表`nums2`，将`nums1`中大于`50`的元素放到`nums2`中。 117 | 118 | ```Python 119 | nums1 = [35, 12, 97, 64, 55] 120 | nums2 = [] 121 | for num in nums1: 122 | if num > 50: 123 | nums2.append(num) 124 | print(nums2) 125 | ``` 126 | 127 | 使用列表生成式做同样的事情，代码如下所示。 128 | 129 | ```Python 130 | nums1 = [35, 12, 97, 64, 55] 131 | nums2 = [num for num in nums1 if num > 50] 132 | print(nums2) 133 | ``` 134 | 135 | 使用列表生成式创建列表不仅代码简单优雅，而且性能上也优于使用`for-in`循环和`append`方法向空列表中追加元素的方式。为什么说生成式有更好的性能呢，那是因为 Python 解释器的字节码指令中有专门针对生成式的指令（`LIST_APPEND`指令）；而`for`循环是通过方法调用（`LOAD_METHOD`和`CALL_METHOD`指令）的方式为列表添加元素，方法调用本身就是一个相对比较耗时的操作。对这一点不理解也没有关系，记住“**强烈建议用生成式语法来创建列表**”这个结论就可以了。 136 | 137 | ### 嵌套列表 138 | 139 | Python 语言没有限定列表中的元素必须是相同的数据类型，也就是说一个列表中的元素可以任意的数据类型，当然也包括列表本身。如果列表中的元素也是列表，那么我们可以称之为嵌套的列表。嵌套的列表可以用来表示表格或数学上的矩阵，例如：我们想保存5个学生3门课程的成绩，可以用如下所示的列表。 140 | 141 | ```python 142 | scores = [[95, 83, 92], [80, 75, 82], [92, 97, 90], [80, 78, 69], [65, 66, 89]] 143 | print(scores[0]) 144 | print(scores[0][1]) 145 | ``` 146 | 147 | 对于上面的嵌套列表，每个元素相当于就是一个学生3门课程的成绩，例如`[95, 83, 92]`，而这个列表中的`83`代表了这个学生某一门课的成绩，如果想访问这个值，可以使用两次索引运算`scores[0][1]`，其中`scores[0]`可以得到`[95, 83, 92]`这个列表，再次使用索引运算`[1]`就可以获得该列表中的第二个元素。 148 | 149 | 如果想通过键盘输入的方式来录入5个学生3门课程的成绩并保存在列表中，可以使用如下所示的代码。 150 | 151 | ```Python 152 | scores = [] 153 | for _ in range(5): 154 | temp = [] 155 | for _ in range(3): 156 | score = int(input('请输入: ')) 157 | temp.append(score) 158 | scores.append(temp) 159 | print(scores) 160 | ``` 161 | 162 | 如果想通过产生随机数的方式来生成5个学生3门课程的成绩并保存在列表中，我们可以使用列表生成式，代码如下所示。 163 | 164 | ```python 165 | import random 166 | 167 | scores = [[random.randrange(60, 101) for _ in range(3)] for _ in range(5)] 168 | print(scores) 169 | ``` 170 | 171 | > **说明**：上面的代码`[random.randrange(60, 101) for _ in range(3)] `可以产生由3个随机整数构成的列表，我们把这段代码又放在了另一个列表生成式中作为列表的元素，这样的元素一共生成5个，最终得到了一个嵌套列表。 172 | 173 | ### 列表应用举例 174 | 175 | 下面我们通过一个双色球随机选号的例子为大家讲解列表的应用。双色球是由中国福利彩票发行管理中心发售的乐透型彩票，每注投注号码由`6`个红色球和`1`个蓝色球组成。红色球号码从`1`到`33`中选择，蓝色球号码从`1`到`16`中选择。每注需要选择`6`个红色球号码和`1`个蓝色球号码，如下所示。 176 | 177 | 178 | 179 | > **提示**：知乎上有一段对国内各种形式的彩票本质的论述相当精彩，这里分享给大家：“**虚构一个不劳而获的人，去忽悠一群想不劳而获的人，最终养活一批真正不劳而获的人**”。很多对概率没有概念的人，甚至认为彩票中与不中的概率都是50%；还有很多人认为如果中奖的概率是1%，那么买100次就一定可以中奖，这些都是非常荒唐的想法。所以，珍爱生命，远离（任何形式的）赌博！ 180 | 181 | 下面，我们通过 Python 程序来生成一组随机号码。 182 | 183 | ```python 184 | """ 185 | 双色球随机选号程序 186 | 187 | Author: 骆昊 188 | Version: 1.0 189 | """ 190 | import random 191 | 192 | red_balls = list(range(1, 34)) 193 | selected_balls = [] 194 | # 添加6个红色球到选中列表 195 | for _ in range(6): 196 | # 生成随机整数代表选中的红色球的索引位置 197 | index = random.randrange(len(red_balls)) 198 | # 将选中的球从红色球列表中移除并添加到选中列表 199 | selected_balls.append(red_balls.pop(index)) 200 | # 对选中的红色球排序 201 | selected_balls.sort() 202 | # 输出选中的红色球 203 | for ball in selected_balls: 204 | print(f'\033[031m{ball:0>2d}\033[0m', end=' ') 205 | # 随机选择1个蓝色球 206 | blue_ball = random.randrange(1, 17) 207 | # 输出选中的蓝色球 208 | print(f'\033[034m{blue_ball:0>2d}\033[0m') 209 | ``` 210 | 211 | > **说明**：上面代码中`print(f'\033[0m...\033[0m')`是为了控制输出内容的颜色，红色球输出成红色，蓝色球输出成蓝色。其中省略号代表我们要输出的内容，`\033[0m`是一个控制码，表示关闭所有属性，也就是说之前的控制码将会失效，你也可以将其简单的理解为一个定界符，`m`前面的`0`表示控制台的显示方式为默认值，`0`可以省略，`1`表示高亮，`5`表示闪烁，`7`表示反显等。在`0`和`m`的中间，我们可以写上代表颜色的数字，比如`30`代表黑色，`31`代表红色，`32`代表绿色，`33`代表黄色，`34`代表蓝色等。 212 | 213 | 我们还可以利用`random`模块提供的`sample`和`choice`函数来简化上面的代码，前者可以实现无放回随机抽样，后者可以实现随机抽取一个元素，修改后的代码如下所示。 214 | 215 | ```python 216 | """ 217 | 双色球随机选号程序 218 | 219 | Author: 骆昊 220 | Version: 1.1 221 | """ 222 | import random 223 | 224 | red_balls = [i for i in range(1, 34)] 225 | blue_balls = [i for i in range(1, 17)] 226 | # 从红色球列表中随机抽出6个红色球（无放回抽样） 227 | selected_balls = random.sample(red_balls, 6) 228 | # 对选中的红色球排序 229 | selected_balls.sort() 230 | # 输出选中的红色球 231 | for ball in selected_balls: 232 | print(f'\033[031m{ball:0>2d}\033[0m', end=' ') 233 | # 从蓝色球列表中随机抽出1个蓝色球 234 | blue_ball = random.choice(blue_balls) 235 | # 输出选中的蓝色球 236 | print(f'\033[034m{blue_ball:0>2d}\033[0m') 237 | ``` 238 | 239 | 如果要实现随机生成`N`注号码，我们只需要将上面的代码放到一个`N`次的循环中，如下所示。 240 | 241 | ```python 242 | """ 243 | 双色球随机选号程序 244 | 245 | Author: 骆昊 246 | Version: 1.2 247 | """ 248 | import random 249 | 250 | n = int(input('生成几注号码: ')) 251 | red_balls = [i for i in range(1, 34)] 252 | blue_balls = [i for i in range(1, 17)] 253 | for _ in range(n): 254 | # 从红色球列表中随机抽出6个红色球（无放回抽样） 255 | selected_balls = random.sample(red_balls, 6) 256 | # 对选中的红色球排序 257 | selected_balls.sort() 258 | # 输出选中的红色球 259 | for ball in selected_balls: 260 | print(f'\033[031m{ball:0>2d}\033[0m', end=' ') 261 | # 从蓝色球列表中随机抽出1个蓝色球 262 | blue_ball = random.choice(blue_balls) 263 | # 输出选中的蓝色球 264 | print(f'\033[034m{blue_ball:0>2d}\033[0m') 265 | ``` 266 | 267 | 我们在 PyCharm 中运行上面的代码，输入`5`，运行效果如下图所示。 268 | 269 | 270 | 271 | ### 总结 272 | 273 | Python 中的列表底层是一个可以动态扩容的数组，列表元素在计算机内存中是连续存储的，所以可以实现随机访问（通过一个有效的索引获取对应的元素且操作时间与列表元素个数无关）。我们可以暂时不去触碰这些底层的存储细节，也不需要大家理解列表每个方法的渐近时间复杂度（执行方法耗费的时间跟列表元素个数之间的关系），大家先学会用列表解决工作中的问题，我想这一点更为重要。 -------------------------------------------------------------------------------- /第10课：常用数据结构之元组.md: -------------------------------------------------------------------------------- 1 | ## 第10课：常用数据结构之元组 2 | 3 | 前面的两节课，我们为大家讲解了 Python 中的列表，它是一种容器型的数据类型，通过列表类型的变量，我们可以保存多个数据并通过循环实现对数据的批量操作。当然，Python 中还有其他容器型的数据类型，接下来我们就为大家讲解另一种容器型的数据类型，它的名字叫元组（tuple）。 4 | 5 | ### 元组的定义和运算 6 | 7 | 在 Python 语言中，元组也是多个元素按照一定顺序构成的序列。元组和列表的不同之处在于，**元组是不可变类型**，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能修改。如果试图修改元组中的元素，将引发`TypeError`错误，导致程序崩溃。定义元组通常使用形如`(x, y, z)`的字面量语法，元组类型支持的运算符跟列表是一样的，我们可以看看下面的代码。 8 | 9 | ```python 10 | # 定义一个三元组 11 | t1 = (35, 12, 98) 12 | # 定义一个四元组 13 | t2 = ('骆昊', 43, True, '四川成都') 14 | 15 | # 查看变量的类型 16 | print(type(t1)) # 17 | print(type(t2)) # 18 | 19 | # 查看元组中元素的数量 20 | print(len(t1)) # 3 21 | print(len(t2)) # 4 22 | 23 | # 索引运算 24 | print(t1[0]) # 35 25 | print(t1[2]) # 98 26 | print(t2[-1]) # 四川成都 27 | 28 | # 切片运算 29 | print(t2[:2]) # ('骆昊', 43) 30 | print(t2[::3]) # ('骆昊', '四川成都') 31 | 32 | # 循环遍历元组中的元素 33 | for elem in t1: 34 | print(elem) 35 | 36 | # 成员运算 37 | print(12 in t1) # True 38 | print(99 in t1) # False 39 | print('Hao' not in t2) # False 40 | 41 | # 拼接运算 42 | t3 = t1 + t2 43 | print(t3) # (35, 12, 98, '骆昊', 43, True, '四川成都') 44 | 45 | # 比较运算 46 | print(t1 == t3) # False 47 | print(t1 >= t3) # False 48 | print(t1 <= (35, 11, 99)) # False 49 | ``` 50 | 51 | 一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，`()`表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则`()`就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以`('hello', )`和`(100, )`才是一元组，而`('hello')`和`(100)`只是字符串和整数。我们可以通过下面的代码来加以验证。 52 | 53 | ```python 54 | a = () 55 | print(type(a)) # 56 | b = ('hello') 57 | print(type(b)) # 58 | c = (100) 59 | print(type(c)) # 60 | d = ('hello', ) 61 | print(type(d)) # 62 | e = (100, ) 63 | print(type(e)) # 64 | ``` 65 | 66 | ### 打包和解包操作 67 | 68 | 当我们把多个用逗号分隔的值赋给一个变量时，多个值会打包成一个元组类型；当我们把一个元组赋值给多个变量时，元组会解包成多个值然后分别赋给对应的变量，如下面的代码所示。 69 | 70 | ```python 71 | # 打包操作 72 | a = 1, 10, 100 73 | print(type(a)) # 74 | print(a) # (1, 10, 100) 75 | # 解包操作 76 | i, j, k = a 77 | print(i, j, k) # 1 10 100 78 | ``` 79 | 80 | 在解包时，如果解包出来的元素个数和变量个数不对应，会引发`ValueError`异常，错误信息为：`too many values to unpack`（解包的值太多）或`not enough values to unpack`（解包的值不足）。 81 | 82 | ```python 83 | a = 1, 10, 100, 1000 84 | # i, j, k = a # ValueError: too many values to unpack (expected 3) 85 | # i, j, k, l, m, n = a # ValueError: not enough values to unpack (expected 6, got 4) 86 | ``` 87 | 88 | 有一种解决变量个数少于元素的个数方法，就是使用星号表达式。通过星号表达式，我们可以让一个变量接收多个值，代码如下所示。需要注意两点：首先，用星号表达式修饰的变量会变成一个列表，列表中有0个或多个元素；其次，在解包语法中，星号表达式只能出现一次。 89 | 90 | ```python 91 | a = 1, 10, 100, 1000 92 | i, j, *k = a 93 | print(i, j, k) # 1 10 [100, 1000] 94 | i, *j, k = a 95 | print(i, j, k) # 1 [10, 100] 1000 96 | *i, j, k = a 97 | print(i, j, k) # [1, 10] 100 1000 98 | *i, j = a 99 | print(i, j) # [1, 10, 100] 1000 100 | i, *j = a 101 | print(i, j) # 1 [10, 100, 1000] 102 | i, j, k, *l = a 103 | print(i, j, k, l) # 1 10 100 [1000] 104 | i, j, k, l, *m = a 105 | print(i, j, k, l, m) # 1 10 100 1000 [] 106 | ``` 107 | 108 | 需要说明一点，解包语法对所有的序列都成立，这就意味着我们之前讲的列表、`range`函数构造的范围序列甚至字符串都可以使用解包语法。大家可以尝试运行下面的代码，看看会出现怎样的结果。 109 | 110 | ```python 111 | a, b, *c = range(1, 10) 112 | print(a, b, c) 113 | a, b, c = [1, 10, 100] 114 | print(a, b, c) 115 | a, *b, c = 'hello' 116 | print(a, b, c) 117 | ``` 118 | 119 | ### 交换变量的值 120 | 121 | 交换变量的值是写代码时经常用到的一个操作，但是在很多编程语言中，交换两个变量的值都需要借助一个中间变量才能做到，如果不用中间变量就需要使用比较晦涩的位运算来实现。在 Python 中，交换两个变量`a`和`b`的值只需要使用如下所示的代码。 122 | 123 | ```python 124 | a, b = b, a 125 | ``` 126 | 127 | 同理，如果要将三个变量`a`、`b`、`c`的值互换，即`b`的值赋给`a`，`c`的值赋给`b`，`a`的值赋给`c`，也可以如法炮制。 128 | 129 | ```python 130 | a, b, c = b, c, a 131 | ``` 132 | 133 | 需要说明的是，上面的操作并没有用到打包和解包语法，Python 的字节码指令中有`ROT_TWO`和`ROT_THREE`这样的指令可以直接实现这个操作，效率是非常高的。但是如果有多于三个变量的值要依次互换，这个时候是没有直接可用的字节码指令的，需要通过打包解包的方式来完成变量之间值的交换。 134 | 135 | ### 元组和列表的比较 136 | 137 | 这里还有一个非常值得探讨的问题，Python 中已经有了列表类型，为什么还需要元组这样的类型呢？这个问题对于初学者来说似乎有点困难，不过没有关系，我们先抛出观点，大家可以一边学习一边慢慢体会。 138 | 139 | 1. 元组是不可变类型，**不可变类型更适合多线程环境**，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解并发编程的时候跟大家一起探讨。 140 | 141 | 2. 元组是不可变类型，通常**不可变类型在创建时间上优于对应的可变类型**。我们可以使用`timeit`模块的`timeit`函数来看看创建保存相同元素的元组和列表各自花费的时间，`timeit`函数的`number`参数表示代码执行的次数。下面的代码中，我们分别创建了保存`1`到`9`的整数的列表和元组，每个操作执行`10000000`次，统计运行时间。 142 | 143 | ```python 144 | import timeit 145 | 146 | print('%.3f 秒' % timeit.timeit('[1, 2, 3, 4, 5, 6, 7, 8, 9]', number=10000000)) 147 | print('%.3f 秒' % timeit.timeit('(1, 2, 3, 4, 5, 6, 7, 8, 9)', number=10000000)) 148 | ``` 149 | 150 | 输出： 151 | 152 | ``` 153 | 0.635 秒 154 | 0.078 秒 155 | ``` 156 | 157 | > **说明**：上面代码的执行结果因软硬件系统而异，在我目前使用的电脑上，执行`10000000`次创建列表的操作时间是`0.635`秒，而执行`10000000`次创建元组的操作时间是`0.078`秒，显然创建元组更快且二者时间上有数量级的差别。大家可以在自己的电脑上执行这段代码，把你的执行结果放到评论区，看看谁的电脑更厉害。 158 | 159 | 当然，Python 中的元组和列表类型是可以相互转换的，我们可以通过下面的代码来完成该操作。 160 | 161 | ```python 162 | infos = ('骆昊', 43, True, '四川成都') 163 | # 将元组转换成列表 164 | print(list(infos)) # ['骆昊', 43, True, '四川成都'] 165 | 166 | frts = ['apple', 'banana', 'orange'] 167 | # 将列表转换成元组 168 | print(tuple(frts)) # ('apple', 'banana', 'orange') 169 | ``` 170 | 171 | ### 总结 172 | 173 | **列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据，而且它们都是按一定顺序组织元素的有序容器。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表可以添加元素、删除元素、清空元素、排序反转，但这些操作对元组来说是不成立的。列表和元组都可以支持**拼接运算**、**成员运算**、**索引运算**、**切片运算**等操作，后面我们要讲到的字符串类型也支持这些运算，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。我们**推荐大家使用列表的生成式语法来创建列表**，它不仅好用而且效率很高，是 Python 语言中非常有特色的语法。 174 | -------------------------------------------------------------------------------- /第11课：常用数据结构之字符串.md: -------------------------------------------------------------------------------- 1 | ## 第11课：常用数据结构之字符串 2 | 3 | 第二次世界大战促使了现代电子计算机的诞生，世界上的第一台通用电子计算机名叫 ENIAC（电子数值积分计算机），诞生于美国的宾夕法尼亚大学，占地167平米，重量约27吨，每秒钟大约能够完成约5000次浮点运算，如下图所示。ENIAC 诞生之后被应用于导弹弹道的计算，而数值计算也是现代电子计算机最为重要的一项功能。 4 | 5 | 6 | 7 | 随着时间的推移，虽然数值运算仍然是计算机日常工作中最为重要的组成部分，但是今天的计算机还要处理大量的以文本形式存在的信息。如果我们希望通过 Python 程序来操作本这些文本信息，就必须要先了解字符串这种数据类型以及与它相关的运算和方法。 8 | 9 | ### 字符串的定义 10 | 11 | 所谓**字符串**，就是**由零个或多个字符组成的有限序列**，一般记为： 12 | $$ 13 | s = a_1a_2 \cdots a_n \,\,\,\,\, (0 \le n \le \infty) 14 | $$ 15 | 在 Python 程序中，我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。字符串中的字符可以是特殊符号、英文字母、中文字符、日文的平假名或片假名、希腊字母、Emoji 字符（如：💩、🐷、🀄️）等。 16 | 17 | ```python 18 | s1 = 'hello, world!' 19 | s2 = "你好，世界！❤️" 20 | s3 = '''hello, 21 | wonderful 22 | world!''' 23 | print(s1) 24 | print(s2) 25 | print(s3) 26 | ``` 27 | 28 | #### 转义字符 29 | 30 | 我们可以在字符串中使用`\`（反斜杠）来表示转义，也就是说`\`后面的字符不再是它原来的意义，例如：`\n`不是代表字符`\`和字符`n`，而是表示换行；`\t`也不是代表字符`\`和字符`t`，而是表示制表符。所以如果字符串本身又包含了`'`、`"`、`\`这些特殊的字符，必须要通过`\`进行转义处理。例如要输出一个带单引号或反斜杠的字符串，需要用如下所示的方法。 31 | 32 | ```python 33 | s1 = '\'hello, world!\'' 34 | s2 = '\\hello, world!\\' 35 | print(s1) 36 | print(s2) 37 | ``` 38 | 39 | #### 原始字符串 40 | 41 | Python 中有一种以`r`或`R`开头的字符串，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串`'hello\n'`中，`\n`表示换行；而在`r'hello\n'`中，`\n`不再表示换行，就是字符`\`和字符`n`。大家可以运行下面的代码，看看会输出什么。 42 | 43 | ```python 44 | s1 = '\it \is \time \to \read \now' 45 | s2 = r'\it \is \time \to \read \now' 46 | print(s1) 47 | print(s2) 48 | ``` 49 | 50 | > **说明**：上面的变量`s1`中，`\t`、`\r`和`\n`都是转义字符。`\t`是制表符（table），`\n`是换行符（new line），`\r`是回车符（carriage return）相当于让输出回到了行首。对比一下两个`print`函数的输出，看看到底有什么区别！ 51 | 52 | #### 字符的特殊表示 53 | 54 | Python 中还允许在`\`后面还可以跟一个八进制或者十六进制数来表示字符，例如`\141`和`\x61`都代表小写字母`a`，前者是八进制的表示法，后者是十六进制的表示法。另外一种表示字符的方式是在`\u`后面跟 Unicode 字符编码，例如`\u9a86\u660a`代表的是中文“骆昊”。运行下面的代码，看看输出了什么。 55 | 56 | ```python 57 | s1 = '\141\142\143\x61\x62\x63' 58 | s2 = '\u9a86\u660a' 59 | print(s1) 60 | print(s2) 61 | ``` 62 | 63 | ### 字符串的运算 64 | 65 | Python 语言为字符串类型提供了非常丰富的运算符，有很多运算符跟列表类型的运算符作用类似。例如，我们可以使用`+`运算符来实现字符串的拼接，可以使用`*`运算符来重复一个字符串的内容，可以使用`in`和`not in`来判断一个字符串是否包含另外一个字符串，我们也可以用`[]`和`[:]`运算符从字符串取出某个字符或某些字符。 66 | 67 | #### 拼接和重复 68 | 69 | 下面的例子演示了使用`+`和`*`运算符来实现字符串的拼接和重复操作。 70 | 71 | ```python 72 | s1 = 'hello' + ', ' + 'world' 73 | print(s1) # hello, world 74 | s2 = '!' * 3 75 | print(s2) # !!! 76 | s1 += s2 77 | print(s1) # hello, world!!! 78 | s1 *= 2 79 | print(s1) # hello, world!!!hello, world!!! 80 | ``` 81 | 82 | 用`*`实现字符串的重复是非常有意思的一个运算符，在很多编程语言中，要表示一个有10个`a`的字符串，你只能写成`'aaaaaaaaaa'`，但是在 Python 中，你可以写成`'a' * 10`。你可能觉得`'aaaaaaaaaa'`这种写法也没有什么不方便的，但是请想一想，如果字符`a`要重复100次或者1000次又会如何呢？ 83 | 84 | #### 比较运算 85 | 86 | 对于两个字符串类型的变量，可以直接使用比较运算符来判断两个字符串的相等性或比较大小。需要说明的是，因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的大小比较比的是每个字符对应的编码的大小。例如`A`的编码是`65`， 而`a`的编码是`97`，所以`'A' < 'a'`的结果相当于就是`65 < 97`的结果，这里很显然是`True`；而`'boy' < 'bad'`，因为第一个字符都是`'b'`比不出大小，所以实际比较的是第二个字符的大小，显然`'o' < 'a'`的结果是`False`，所以`'boy' < 'bad'`的结果是`False`。如果不清楚两个字符对应的编码到底是多少，可以使用`ord`函数来获得，之前我们有提到过这个函数。例如`ord('A')`的值是`65`，而`ord('昊')`的值是`26122`。下面的代码展示了字符串的比较运算，请大家仔细看看。 87 | 88 | ```python 89 | s1 = 'a whole new world' 90 | s2 = 'hello world' 91 | print(s1 == s2) # False 92 | print(s1 < s2) # True 93 | print(s1 == 'hello world') # False 94 | print(s2 == 'hello world') # True 95 | print(s2 != 'Hello world') # True 96 | s3 = '骆昊' 97 | print(ord('骆')) # 39558 98 | print(ord('昊')) # 26122 99 | s4 = '王大锤' 100 | print(ord('王')) # 29579 101 | print(ord('大')) # 22823 102 | print(ord('锤')) # 38180 103 | print(s3 >= s4) # True 104 | print(s3 != s4) # True 105 | ``` 106 | 107 | #### 成员运算 108 | 109 | Python 中可以用`in`和`not in`判断一个字符串中是否包含另外一个字符或字符串，跟列表类型一样，`in`和`not in`称为成员运算符，会产生布尔值`True`或`False`，代码如下所示。 110 | 111 | ```python 112 | s1 = 'hello, world' 113 | s2 = 'goodbye, world' 114 | print('wo' in s1) # True 115 | print('wo' not in s2) # False 116 | print(s2 in s1) # False 117 | ``` 118 | 119 | #### 获取字符串长度 120 | 121 | 获取字符串长度跟获取列表元素个数一样，使用内置函数`len`，代码如下所示。 122 | 123 | ```python 124 | s = 'hello, world' 125 | print(len(s)) # 12 126 | print(len('goodbye, world')) # 14 127 | ``` 128 | 129 | #### 索引和切片 130 | 131 | 字符串的索引和切片操作跟列表几乎区别，因为字符串也是一种有序序列，可以通过正向或反向的整数索引访问其中的元素。但是有一点需要注意，因为**字符串是不可变类型**，所以**不能通过索引运算修改字符串中的字符**。 132 | 133 | ```python 134 | s = 'abc123456' 135 | n = len(s) 136 | print(s[0], s[-n]) # a a 137 | print(s[n-1], s[-1]) # 6 6 138 | print(s[2], s[-7]) # c c 139 | print(s[5], s[-4]) # 3 3 140 | print(s[2:5]) # c12 141 | print(s[-7:-4]) # c12 142 | print(s[2:]) # c123456 143 | print(s[:2]) # ab 144 | print(s[::2]) # ac246 145 | print(s[::-1]) # 654321cba 146 | ``` 147 | 148 | 需要再次提醒大家注意的是，在进行索引运算时，如果索引越界，会引发`IndexError`异常，错误提示信息为：`string index out of range`（字符串索引超出范围）。 149 | 150 | ### 字符的遍历 151 | 152 | 如果希望遍历字符串中的每个字符，可以使用`for-in`循环，有如下所示的两种方式。 153 | 154 | 方式一： 155 | 156 | ```python 157 | s = 'hello' 158 | for i in range(len(s)): 159 | print(s[i]) 160 | ``` 161 | 162 | 方式二： 163 | 164 | ```python 165 | s = 'hello' 166 | for elem in s: 167 | print(elem) 168 | ``` 169 | 170 | ### 字符串的方法 171 | 172 | 在 Python 中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，假设我们有名为`foo`的字符串，字符串有名为`bar`的方法，那么使用字符串方法的语法是：`foo.bar()`，这是一种通过对象引用调用对象方法的语法，跟前面使用列表方法的语法是一样的。 173 | 174 | #### 大小写相关操作 175 | 176 | 下面的代码演示了和字符串大小写变换相关的方法。 177 | 178 | ```python 179 | s1 = 'hello, world!' 180 | # 字符串首字母大写 181 | print(s1.capitalize()) # Hello, world! 182 | # 字符串每个单词首字母大写 183 | print(s1.title()) # Hello, World! 184 | # 字符串变大写 185 | print(s1.upper()) # HELLO, WORLD! 186 | s2 = 'GOODBYE' 187 | # 字符串变小写 188 | print(s2.lower()) # goodbye 189 | # 检查s1和s2的值 190 | print(s1) # hello, world 191 | print(s2) # GOODBYE 192 | ``` 193 | 194 | > **说明**：由于字符串是不可变类型，使用字符串的方法对字符串进行操作会产生新的字符串，但是原来变量的值并没有发生变化。所以上面的代码中，当我们最后检查`s1`和`s2`两个变量的值时，`s1`和`s2` 的值并没有发生变化。 195 | 196 | #### 查找操作 197 | 198 | 如果想在一个字符串中从前向后查找有没有另外一个字符串，可以使用字符串的`find`或`index`方法。在使用`find`和`index`方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为`0`的位置开始。 199 | 200 | ```python 201 | s = 'hello, world!' 202 | print(s.find('or')) # 8 203 | print(s.find('or', 9)) # -1 204 | print(s.find('of')) # -1 205 | print(s.index('or')) # 8 206 | print(s.index('or', 9)) # ValueError: substring not found 207 | ``` 208 | 209 | >**说明**：`find`方法找不到指定的字符串会返回`-1`，`index`方法找不到指定的字符串会引发`ValueError`错误。 210 | 211 | `find`和`index`方法还有逆向查找（从后向前查找）的版本，分别是`rfind`和`rindex`，代码如下所示。 212 | 213 | ```python 214 | s = 'hello world!' 215 | print(s.find('o')) # 4 216 | print(s.rfind('o')) # 7 217 | print(s.rindex('o')) # 7 218 | # print(s.rindex('o', 8)) # ValueError: substring not found 219 | ``` 220 | 221 | #### 性质判断 222 | 223 | 可以通过字符串的`startswith`、`endswith`来判断字符串是否以某个字符串开头和结尾；还可以用`is`开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。 224 | 225 | ```python 226 | s1 = 'hello, world!' 227 | print(s1.startswith('He')) # False 228 | print(s1.startswith('hel')) # True 229 | print(s1.endswith('!')) # True 230 | s2 = 'abc123456' 231 | print(s2.isdigit()) # False 232 | print(s2.isalpha()) # False 233 | print(s2.isalnum()) # True 234 | ``` 235 | 236 | > **说明**：上面的`isdigit`用来判断字符串是不是完全由数字构成的，`isalpha`用来判断字符串是不是完全由字母构成的，这里的字母指的是 Unicode 字符但不包含 Emoji 字符，`isalnum`用来判断字符串是不是由字母和数字构成的。 237 | 238 | #### 格式化字符串 239 | 240 | 在 Python 中，字符串类型可以通过`center`、`ljust`、`rjust`方法做居中、左对齐和右对齐的处理。如果要在字符串的左侧补零，也可以使用`zfill`方法。 241 | 242 | ```python 243 | s = 'hello, world' 244 | print(s.center(20, '*')) # ****hello, world**** 245 | print(s.rjust(20)) # hello, world 246 | print(s.ljust(20, '~')) # hello, world~~~~~~~~ 247 | print('33'.zfill(5)) # 00033 248 | print('-33'.zfill(5)) # -0033 249 | ``` 250 | 251 | 我们之前讲过，在用`print`函数输出字符串时，可以用下面的方式对字符串进行格式化。 252 | 253 | ```python 254 | a = 321 255 | b = 123 256 | print('%d * %d = %d' % (a, b, a * b)) 257 | ``` 258 | 259 | 当然，我们也可以用字符串的`format`方法来完成字符串的格式，代码如下所示。 260 | 261 | ```python 262 | a = 321 263 | b = 123 264 | print('{0} * {1} = {2}'.format(a, b, a * b)) 265 | ``` 266 | 267 | 从 Python 3.6 开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上`f`来格式化字符串，在这种以`f`打头的字符串中，`{变量名}`是一个占位符，会被变量对应的值将其替换掉，代码如下所示。 268 | 269 | ```python 270 | a = 321 271 | b = 123 272 | print(f'{a} * {b} = {a * b}') 273 | ``` 274 | 275 | 如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。 276 | 277 | | 变量值 | 占位符 | 格式化结果 | 说明 | 278 | | ----------- | ---------- | ------------- | ---- | 279 | | `3.1415926` | `{:.2f}` | `'3.14'` | 保留小数点后两位 | 280 | | `3.1415926` | `{:+.2f}` | `'+3.14'` | 带符号保留小数点后两位 | 281 | | `-1` | `{:+.2f}` | `'-1.00'` | 带符号保留小数点后两位 | 282 | | `3.1415926` | `{:.0f}` | `'3'` | 不带小数 | 283 | | `123` | `{:0>10d}` | `'0000000123'` | 左边补`0`，补够10位 | 284 | | `123` | `{:x<10d}` | `'123xxxxxxx'` | 右边补`x` ，补够10位 | 285 | | `123` | `{:>10d}` | `' 123'` | 左边补空格，补够10位 | 286 | | `123` | `{:<10d}` | `'123 '` | 右边补空格，补够10位 | 287 | | `123456789` | `{:,}` | `'123,456,789'` | 逗号分隔格式 | 288 | | `0.123` | `{:.2%}` | `'12.30%'` | 百分比格式 | 289 | | `123456789` | `{:.2e}` | `'1.23e+08'` | 科学计数法格式 | 290 | 291 | #### 修剪操作 292 | 293 | 字符串的`strip`方法可以帮我们获得将原字符串修剪掉左右两端指定字符之后的字符串，默认是修剪空格字符。这个方法非常有实用价值，可以用来将用户输入时不小心键入的头尾空格等去掉，`strip`方法还有`lstrip`和`rstrip`两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。 294 | 295 | ```python 296 | s1 = ' jackfrued@126.com ' 297 | print(s1.strip()) # jackfrued@126.com 298 | s2 = '~你好，世界~' 299 | print(s2.lstrip('~')) # 你好，世界~ 300 | print(s2.rstrip('~')) # ~你好，世界 301 | ``` 302 | 303 | #### 替换操作 304 | 305 | 如果希望用新的内容替换字符串中指定的内容，可以使用`replace`方法，代码如下所示。`replace`方法的第一个参数是被替换的内容，第二个参数是替换后的内容，还可以通过第三个参数指定替换的次数。 306 | 307 | ```python 308 | s = 'hello, good world' 309 | print(s.replace('o', '@')) # hell@, g@@d w@rld 310 | print(s.replace('o', '@', 1)) # hell@, good world 311 | ``` 312 | 313 | #### 拆分与合并 314 | 315 | 可以使用字符串的`split`方法将一个字符串拆分为多个字符串（放在一个列表中），也可以使用字符串的`join`方法将列表中的多个字符串连接成一个字符串，代码如下所示。 316 | 317 | ```python 318 | s = 'I love you' 319 | words = s.split() 320 | print(words) # ['I', 'love', 'you'] 321 | print('~'.join(words)) # I~love~you 322 | ``` 323 | 324 | 需要说明的是，`split`方法默认使用空格进行拆分，我们也可以指定其他的字符来拆分字符串，而且还可以指定最大拆分次数来控制拆分的效果，代码如下所示。 325 | 326 | ```python 327 | s = 'I#love#you#so#much' 328 | words = s.split('#') 329 | print(words) # ['I', 'love', 'you', 'so', 'much'] 330 | words = s.split('#', 2) 331 | print(words) # ['I', 'love', 'you#so#much'] 332 | ``` 333 | 334 | #### 编码和解码 335 | 336 | Python 中除了字符串`str`类型外，还有一种表示二进制数据的字节串类型（`bytes`）。所谓字节串，就是**由零个或多个字节组成的有限序列**。通过字符串的`encode`方法，我们可以按照某种编码方式将字符串编码为字节串，我们也可以使用字节串的`decode`方法，将字节串解码为字符串，代码如下所示。 337 | 338 | ```python 339 | a = '骆昊' 340 | b = a.encode('utf-8') 341 | c = a.encode('gbk') 342 | print(b) # b'\xe9\xaa\x86\xe6\x98\x8a' 343 | print(c) # b'\xc2\xe6\xea\xbb' 344 | print(b.decode('utf-8')) # 骆昊 345 | print(c.decode('gbk')) # 骆昊 346 | ``` 347 | 348 | 注意，如果编码和解码的方式不一致，会导致乱码问题（无法再现原始的内容）或引发`UnicodeDecodeError`错误，导致程序崩溃。 349 | 350 | #### 其他方法 351 | 352 | 对于字符串类型来说，还有一个常用的操作是对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python 语言通过标准库中的`re`模块提供了对正则表达式的支持，我们会在后续的课程中为大家讲解这个知识点。 353 | 354 | ### 总结 355 | 356 | 知道如何表示和操作字符串对程序员来说是非常重要的，因为我们经常需要处理文本信息，Python 中操作字符串可以用拼接、索引、切片等运算符，也可以使用字符串类型提供的非常丰富的方法。 357 | -------------------------------------------------------------------------------- /第12课：常用数据结构之集合.md: -------------------------------------------------------------------------------- 1 | ## 第12课：常用数据结构之集合 2 | 3 | 在学习了列表和元组之后，我们再来学习一种容器型的数据类型，它的名字叫集合（set）。说到集合这个词大家一定不会陌生，在数学课本上就有这个概念。如果我们**把一定范围的、确定的、可以区别的事物当作一个整体来看待**，那么这个整体就是集合，集合中的各个事物称为集合的**元素**。通常，集合需要满足以下特性： 4 | 5 | 1. **无序性**：一个集合中，每个元素的地位都是相同的，元素之间是无序的。 6 | 2. **互异性**：一个集合中，任何两个元素都是不相同的，即元素在集合中只能出现一次。 7 | 3. **确定性**：给定一个集合和一个任意元素，该元素要么属这个集合，要么不属于这个集合，二者必居其一，不允许有模棱两可的情况出现。 8 | 9 | Python 程序中的集合跟数学上的集合没有什么本质区别，需要强调的是上面所说的无序性和互异性。无序性说明集合中的元素并不像列中的元素那样存在某种次序，可以通过索引运算就能访问任意元素，**集合并不支持索引运算**。另外，集合的互异性决定了**集合中不能有重复元素**，这一点也是集合区别于列表的地方，我们无法将重复的元素添加到一个集合中。集合类型必然是支持`in`和`not in`成员运算的，这样就可以确定一个元素是否属于集合，也就是上面所说的集合的确定性。**集合的成员运算在性能上要优于列表的成员运算**，这是集合的底层存储特性决定的，此处我们暂时不做讨论，大家记住这个结论即可。 10 | 11 | > **说明**：集合底层使用了哈希存储（散列存储），对哈希存储感兴趣的读者可以看看维基百科上“散列表”这个词条。 12 | 13 | ### 创建集合 14 | 15 | 在 Python 中，创建集合可以使用`{}`字面量语法，`{}`中需要至少有一个元素，因为没有元素的`{}`并不是空集合而是一个空字典，字典类型我们会在下一节课中为大家介绍。当然，也可以使用 Python 内置函数`set`来创建一个集合，准确的说`set`并不是一个函数，而是创建集合对象的构造器，这个知识点会在后面讲解面向对象编程的地方为大家介绍。我们可以使用`set`函数创建一个空集合，也可以用它将其他序列转换成集合，例如：`set('hello')`会得到一个包含了`4`个字符的集合（重复的字符`l`只会在集合中出现一次）。除了这两种方式，还可以使用生成式语法来创建集合，就像我们之前用生成式语法创建列表那样。 16 | 17 | ```python 18 | set1 = {1, 2, 3, 3, 3, 2} 19 | print(set1) 20 | 21 | set2 = {'banana', 'pitaya', 'apple', 'apple', 'banana', 'grape'} 22 | print(set2) 23 | 24 | set3 = set('hello') 25 | print(set3) 26 | 27 | set4 = set([1, 2, 2, 3, 3, 3, 2, 1]) 28 | print(set4) 29 | 30 | set5 = {num for num in range(1, 20) if num % 3 == 0 or num % 7 == 0} 31 | print(set5) 32 | ``` 33 | 34 | 需要提醒大家，集合中的元素必须是`hashable`类型，使用哈希存储的容器都会对元素提出这一要求。所谓`hashable`类型指的是能够计算出哈希码的数据类型，通常不可变类型都是`hashable`类型，如整数（`int`）、浮点小数（`float`）、布尔值（`bool`）、字符串（`str`）、元组（`tuple`）等。可变类型都不是`hashable`类型，因为可变类型无法计算出确定的哈希码，所以它们不能放到集合中。例如：我们不能将列表作为集合中的元素；同理，由于集合本身也是可变类型，所以集合也不能作为集合中的元素。我们可以创建出嵌套的列表，但是我们不能创建出嵌套的集合，这一点在使用集合的时候一定要引起注意。 35 | 36 | ### 集合的遍历 37 | 38 | 我们可以通过`len`函数来获得集合中有多少个元素，但是我们不能通过索引运算来遍历集合中的元素，因为集合元素并没有特定的顺序。当然，要实现对集合元素的遍历，我们仍然可以使用`for-in`循环，代码如下所示。 39 | 40 | ```python 41 | set1 = {'Python', 'C++', 'Java', 'Kotlin', 'Swift'} 42 | for elem in set1: 43 | print(elem) 44 | ``` 45 | 46 | > **提示**：大家看看上面代码的运行结果，通过单词输出的顺序体会一下集合的无序性。 47 | 48 | ### 集合的运算 49 | 50 | Python 为集合类型提供了非常丰富的运算符，主要包括：成员运算、交集运算、并集运算、差集运算、比较运算（相等性、子集、超集）等。 51 | 52 | #### 成员运算 53 | 54 | 可以通过成员运算`in`和`not in `检查元素是否在集合中，代码如下所示。 55 | 56 | ```python 57 | set1 = {11, 12, 13, 14, 15} 58 | print(10 in set1) # False 59 | print(15 in set1) # True 60 | set2 = {'Python', 'Java', 'C++', 'Swift'} 61 | print('Ruby' in set2) # False 62 | print('Java' in set2) # True 63 | ``` 64 | 65 | #### 二元运算 66 | 67 | 集合的二元运算主要指集合的交集、并集、差集、对称差等运算，这些运算可以通过运算符来实现，也可以通过集合类型的方法来实现，代码如下所示。 68 | 69 | 70 | 71 | ```python 72 | set1 = {1, 2, 3, 4, 5, 6, 7} 73 | set2 = {2, 4, 6, 8, 10} 74 | 75 | # 交集 76 | print(set1 & set2) # {2, 4, 6} 77 | print(set1.intersection(set2)) # {2, 4, 6} 78 | 79 | # 并集 80 | print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 10} 81 | print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8, 10} 82 | 83 | # 差集 84 | print(set1 - set2) # {1, 3, 5, 7} 85 | print(set1.difference(set2)) # {1, 3, 5, 7} 86 | 87 | # 对称差 88 | print(set1 ^ set2) # {1, 3, 5, 7, 8, 10} 89 | print(set1.symmetric_difference(set2)) # {1, 3, 5, 7, 8, 10} 90 | ``` 91 | 92 | 通过上面的代码可以看出，对两个集合求交集，`&`运算符和`intersection`方法的作用是完全相同的，使用运算符的方式显然更直观且代码也更简短。需要说明的是，集合的二元运算还可以跟赋值运算一起构成复合赋值运算，例如：`set1 |= set2`相当于`set1 = set1 | set2`，跟`|=`作用相同的方法是`update`；`set1 &= set2`相当于`set1 = set1 & set2`，跟`&=`作用相同的方法是`intersection_update`，代码如下所示。 93 | 94 | ```python 95 | set1 = {1, 3, 5, 7} 96 | set2 = {2, 4, 6} 97 | set1 |= set2 98 | # set1.update(set2) 99 | print(set1) # {1, 2, 3, 4, 5, 6, 7} 100 | set3 = {3, 6, 9} 101 | set1 &= set3 102 | # set1.intersection_update(set3) 103 | print(set1) # {3, 6} 104 | set2 -= set1 105 | # set2.difference_update(set1) 106 | print(set2) # {2, 4} 107 | ``` 108 | 109 | #### 比较运算 110 | 111 | 两个集合可以用`==`和`!=`进行相等性判断，如果两个集合中的元素完全相同，那么`==`比较的结果就是`True`，否则就是`False`。如果集合`A`的任意一个元素都是集合`B`的元素，那么集合`A`称为集合`B`的子集，即对于$\small{\forall{a} \in {A}}$，均有$\small{{a} \in {B}}$，则$\small{{A} \subseteq {B}}$，`A`是`B`的子集，反过来也可以称`B`是`A`的超集。如果`A`是`B`的子集且`A`不等于`B`，那么`A`就是`B`的真子集。Python 为集合类型提供了判断子集和超集的运算符，其实就是我们非常熟悉的`<`、`<=`、`>`、`>=`这些运算符。当然，我们也可以通过集合类型的方法`issubset`和`issuperset`来判断集合之间的关系，代码如下所示。 112 | 113 | ```python 114 | set1 = {1, 3, 5} 115 | set2 = {1, 2, 3, 4, 5} 116 | set3 = {5, 4, 3, 2, 1} 117 | 118 | print(set1 < set2) # True 119 | print(set1 <= set2) # True 120 | print(set2 < set3) # False 121 | print(set2 <= set3) # True 122 | print(set2 > set1) # True 123 | print(set2 == set3) # True 124 | 125 | print(set1.issubset(set2)) # True 126 | print(set2.issuperset(set1)) # True 127 | ``` 128 | 129 | > **说明**：上面的代码中，`set1 < set2`判断`set1`是不是`set2`的真子集，`set1 <= set2`判断`set1`是不是`set2`的子集，`set2 > set1`判断`set2`是不是`set1`的超集。当然，我们也可以通过`set1.issubset(set2)`判断`set1`是不是`set2`的子集；通过`set2.issuperset(set1)`判断`set2`是不是`set1`的超集。 130 | 131 | ### 集合的方法 132 | 133 | 刚才我们说过，Python 中的集合是可变类型，我们可以通过集合类型的方法向集合添加元素或从集合中删除元素。 134 | 135 | ```python 136 | set1 = {1, 10, 100} 137 | 138 | # 添加元素 139 | set1.add(1000) 140 | set1.add(10000) 141 | print(set1) # {1, 100, 1000, 10, 10000} 142 | 143 | # 删除元素 144 | set1.discard(10) 145 | if 100 in set1: 146 | set1.remove(100) 147 | print(set1) # {1, 1000, 10000} 148 | 149 | # 清空元素 150 | set1.clear() 151 | print(set1) # set() 152 | ``` 153 | 154 | > **说明**：删除集合元素的`remove`方法在元素不存在时会引发`KeyError`错误，所以上面的代码中我们先通过成员运算判断元素是否在集合中。集合类型还有一个`pop`方法可以从集合中随机删除一个元素，该方法在删除元素的同时会获得被删除的元素，而`remove`和`discard`方法仅仅是删除元素，不会获得被删除的元素。 155 | 156 | 集合类型还有一个名为`isdisjoint`的方法可以判断两个集合有没有相同的元素，如果没有相同元素，该方法返回`True`，否则该方法返回`False`，代码如下所示。 157 | 158 | ```python 159 | set1 = {'Java', 'Python', 'C++', 'Kotlin'} 160 | set2 = {'Kotlin', 'Swift', 'Java', 'Dart'} 161 | set3 = {'HTML', 'CSS', 'JavaScript'} 162 | print(set1.isdisjoint(set2)) # False 163 | print(set1.isdisjoint(set3)) # True 164 | ``` 165 | 166 | ### 不可变集合 167 | 168 | Python 中还有一种不可变类型的集合，名字叫`frozenset`。`set`跟`frozenset`的区别就如同`list`跟`tuple`的区别，`frozenset`由于是不可变类型，能够计算出哈希码，因此它可以作为`set`中的元素。除了不能添加和删除元素，`frozenset`在其他方面跟`set`是一样的，下面的代码简单的展示了`frozenset`的用法。 169 | 170 | ```python 171 | fset1 = frozenset({1, 3, 5, 7}) 172 | fset2 = frozenset(range(1, 6)) 173 | print(fset1) # frozenset({1, 3, 5, 7}) 174 | print(fset2) # frozenset({1, 2, 3, 4, 5}) 175 | print(fset1 & fset2) # frozenset({1, 3, 5}) 176 | print(fset1 | fset2) # frozenset({1, 2, 3, 4, 5, 7}) 177 | print(fset1 - fset2) # frozenset({7}) 178 | print(fset1 < fset2) # False 179 | ``` 180 | 181 | ### 总结 182 | 183 | Python 中的**集合类型是一种无序容器**，**不允许有重复运算**，由于底层使用了哈希存储，集合中的元素必须是`hashable`类型。集合与列表最大的区别在于**集合中的元素没有顺序**、所以**不能够通过索引运算访问元素**、但是集合可以执行交集、并集、差集等二元运算，也可以通过关系运算符检查两个集合是否存在超集、子集等关系。 184 | -------------------------------------------------------------------------------- /第13课：常用数据结构之字典.md: -------------------------------------------------------------------------------- 1 | ## 第13课：常用数据结构之字典 2 | 3 | 迄今为止，我们已经为大家介绍了Python中的三种容器型数据类型（列表、元组、集合），但是这些数据类型仍然不足以帮助我们解决所有的问题。例如，我们需要一个变量来保存一个人的多项信息，包括：姓名、年龄、身高、体重、家庭住址、本人手机号、紧急联系人手机号，此时你会发现，我们之前学过的列表、元组和集合类型都不够好使。 4 | 5 | ```Python 6 | person1 = ['王大锤', 55, 168, 60, '成都市武侯区科华北路62号1栋101', '13122334455', '13800998877'] 7 | person2 = ('王大锤', 55, 168, 60, '成都市武侯区科华北路62号1栋101', '13122334455', '13800998877') 8 | person3 = {'王大锤', 55, 168, 60, '成都市武侯区科华北路62号1栋101', '13122334455', '13800998877'} 9 | ``` 10 | 11 | 集合肯定是最不合适的，因为集合中不能有重复元素，如果一个人的年龄和体重刚好相同，那么集合中就会少一项信息；同理，如果这个人的手机号和紧急联系人手机号是相同的，那么集合中又会少一项信息。另一方面，虽然列表和元组可以把一个人的所有信息都保存下来，但是当你想要获取这个人的手机号或家庭住址时，你得先知道他的手机号是列表或元组中的第几个元素。总之，在遇到上述的场景时，列表、元组、集合都不是最合适的选择，此时我们需要字典（dictionary）类型，这种数据类型最适合把相关联的信息组装到一起，可以帮助我们解决 Python 程序中为真实事物建模的问题。 12 | 13 | 说到字典这个词，大家一定不陌生，读小学的时候，每个人手头基本上都有一本《新华字典》，如下图所示。 14 | 15 | 16 | 17 | Python 程序中的字典跟现实生活中的字典很像，它以键值对（键和值的组合）的方式把数据组织到一起，我们可以通过键找到与之对应的值并进行操作。就像《新华字典》中，每个字（键）都有与它对应的解释（值）一样，每个字和它的解释合在一起就是字典中的一个条目，而字典中通常包含了很多个这样的条目。 18 | 19 | ### 创建和使用字典 20 | 21 | Python 中创建字典可以使用`{}`字面量语法，这一点跟上一节课讲的集合是一样的。但是字典的`{}`中的元素是以键值对的形式存在的，每个元素由`:`分隔的两个值构成，`:`前面是键，`:`后面是值，代码如下所示。 22 | 23 | ```Python 24 | xinhua = { 25 | '麓': '山脚下', 26 | '路': '道，往来通行的地方；方面，地区：南～货，外～货；种类：他俩是一～人', 27 | '蕗': '甘草的别名', 28 | '潞': '潞水，水名，即今山西省的浊漳河；潞江，水名，即云南省的怒江' 29 | } 30 | print(xinhua) 31 | person = { 32 | 'name': '王大锤', 33 | 'age': 55, 34 | 'height': 168, 35 | 'weight': 60, 36 | 'addr': '成都市武侯区科华北路62号1栋101', 37 | 'tel': '13122334455', 38 | 'emergence contact': '13800998877' 39 | } 40 | print(person) 41 | ``` 42 | 43 | 通过上面的代码，相信大家已经看出来了，用字典来保存一个人的信息远远优于使用列表或元组，因为我们可以用`:`前面的键来表示条目的含义，而`:`后面就是这个条目所对应的值。 44 | 45 | 当然，如果愿意，我们也可以使用内置函数`dict`或者是字典的生成式语法来创建字典，代码如下所示。 46 | 47 | ```Python 48 | # dict函数(构造器)中的每一组参数就是字典中的一组键值对 49 | person = dict(name='王大锤', age=55, height=168, weight=60, addr='成都市武侯区科华北路62号1栋101') 50 | print(person) # {'name': '王大锤', 'age': 55, 'height': 168, 'weight': 60, 'addr': '成都市武侯区科华北路62号1栋101'} 51 | 52 | # 可以通过Python内置函数zip压缩两个序列并创建字典 53 | items1 = dict(zip('ABCDE', '12345')) 54 | print(items1) # {'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'} 55 | items2 = dict(zip('ABCDE', range(1, 10))) 56 | print(items2) # {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5} 57 | 58 | # 用字典生成式语法创建字典 59 | items3 = {x: x ** 3 for x in range(1, 6)} 60 | print(items3) # {1: 1, 2: 8, 3: 27, 4: 64, 5: 125} 61 | ``` 62 | 63 | 想知道字典中一共有多少组键值对，仍然是使用`len`函数；如果想对字典进行遍历，可以用`for`循环，但是需要注意，`for`循环只是对字典的键进行了遍历，不过没关系，在学习了字典的索引运算后，我们可以通过字典的键获取到和这个键对应的值。 64 | 65 | ```Python 66 | person = {'name': '王大锤', 'age': 55, 'height': 168, 'weight': 60, 'addr': '成都市武侯区科华北路62号1栋101'} 67 | print(len(person)) # 5 68 | for key in person: 69 | print(key) 70 | ``` 71 | 72 | ### 字典的运算 73 | 74 | 对于字典类型来说，成员运算和索引运算肯定是很重要的，前者可以判定指定的键在不在字典中，后者可以通过键获取对应的值或者向字典中添加新的键值对。值得注意的是，字典的索引不同于列表的索引，列表中的元素因为有属于自己有序号，所以列表的索引是一个整数；字典中因为保存的是键值对，所以字典需要用键去索引对应的值。需要**特别提醒**大家注意的是，**字典中的键必须是不可变类型**，例如整数（`int`）、浮点数（`float`）、字符串（`str`）、元组（`tuple`）等类型，这一点跟集合类型对元素的要求是一样的；很显然，之前我们讲的列表（`list`）和集合（`set`）不能作为字典中的键，字典类型本身也不能再作为字典中的键，因为字典也是可变类型，但是字典可以作为字典中的值。大家可以先看看下面的代码，了解一下字典的成员运算和索引运算。 75 | 76 | ```Python 77 | person = {'name': '王大锤', 'age': 55, 'height': 168, 'weight': 60, 'addr': '成都市武侯区科华北路62号1栋101'} 78 | 79 | # 成员运算 80 | print('name' in person) # True 81 | print('tel' in person) # False 82 | 83 | # 索引运算 84 | print(person['name']) 85 | print(person['addr']) 86 | person['age'] = 25 87 | person['height'] = 178 88 | person['tel'] = '13122334455' 89 | person['signature'] = '你的男朋友是一个盖世垃圾，他会踏着五彩祥云去迎娶你的闺蜜' 90 | print(person) 91 | 92 | # 循环遍历 93 | for key in person: 94 | print(f'{key}:\t{person[key]}') 95 | ``` 96 | 97 | 需要注意，在通过索引运算获取字典中的值时，如指定的键没有在字典中，将会引发`KeyError`异常。 98 | 99 | ### 字典的方法 100 | 101 | 字典类型的方法基本上都跟字典的键值对操作相关，其中`get`方法可以通过键来获取对应的值。跟索引运算不同的是，`get`方法在字典中没有指定的键时不会产生异常，而是返回`None`或指定的默认值，代码如下所示。 102 | 103 | ```python 104 | person = {'name': '王大锤', 'age': 25, 'height': 178, 'addr': '成都市武侯区科华北路62号1栋101'} 105 | print(person.get('name')) # 王大锤 106 | print(person.get('sex')) # None 107 | print(person.get('sex', True)) # True 108 | ``` 109 | 110 | 如果需要获取字典中所有的键，可以使用`keys`方法；如果需要获取字典中所有的值，可以使用`values`方法。字典还有一个名为`items`的方法，它会将键和值组装成二元组，通过该方法来遍历字典中的元素也是非常方便的。 111 | 112 | ```python 113 | person = {'name': '王大锤', 'age': 25, 'height': 178} 114 | print(person.keys()) # dict_keys(['name', 'age', 'height']) 115 | print(person.values()) # dict_values(['王大锤', 25, 178]) 116 | print(person.items()) # dict_items([('name', '王大锤'), ('age', 25), ('height', 178)]) 117 | for key, value in person.items(): 118 | print(f'{key}:\t{value}') 119 | ``` 120 | 121 | 字典的`update`方法会用一个字典更新另一个字典中的键值对。例如，有两个字典`x`和`y`，当执行`x.update(y)`操作时，`x`跟`y`相同的键对应的值会`y`中的值被更新，而`y`中有但`x`中没有的键值对会直接添加到`x`中，代码如下所示。 122 | 123 | ```python 124 | person1 = {'name': '王大锤', 'age': 55, 'height': 178} 125 | person2 = {'age': 25, 'addr': '成都市武侯区科华北路62号1栋101'} 126 | person1.update(person2) 127 | print(person1) # {'name': '王大锤', 'age': 25, 'height': 178, 'addr': '成都市武侯区科华北路62号1栋101'} 128 | ``` 129 | 130 | 可以通过`pop`或`popitem`方法从字典中删除元素，前者会返回键对应的值，但是如果字典中不存在指定的键，会引发`KeyError`错误；后者在删除元素时，会返回键和值组成的二元组。字典的`clear`方法会清空字典中所有的键值对，代码如下所示。 131 | 132 | ```python 133 | person = {'name': '王大锤', 'age': 25, 'height': 178, 'addr': '成都市武侯区科华北路62号1栋101'} 134 | print(person.pop('age')) # 25 135 | print(person) # {'name': '王大锤', 'height': 178, 'addr': '成都市武侯区科华北路62号1栋101'} 136 | print(person.popitem()) # ('addr', '成都市武侯区科华北路62号1栋101') 137 | print(person) # {'name': '王大锤', 'height': 178} 138 | person.clear() 139 | print(person) # {} 140 | ``` 141 | 142 | 跟列表一样，从字典中删除元素也可以使用`del`关键字，在删除元素的时候如果指定的键索引不到对应的值，一样会引发`KeyError`错误，具体的做法如下所示。 143 | 144 | ```Python 145 | person = {'name': '王大锤', 'age': 25, 'height': 178, 'addr': '成都市武侯区科华北路62号1栋101'} 146 | del person['age'] 147 | del person['addr'] 148 | print(person) # {'name': '王大锤', 'height': 178} 149 | ``` 150 | 151 | ### 字典的应用 152 | 153 | 我们通过几个简单的例子来看看如何使用字典类型解决一些实际的问题。 154 | 155 | **例子1**：输入一段话，统计每个英文字母出现的次数，按出现次数从高到低输出。 156 | 157 | ```Python 158 | sentence = input('请输入一段话: ') 159 | counter = {} 160 | for ch in sentence: 161 | if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z': 162 | counter[ch] = counter.get(ch, 0) + 1 163 | sorted_keys = sorted(counter, key=counter.get, reverse=True) 164 | for key in sorted_keys: 165 | print(f'{key} 出现了 {counter[key]} 次.') 166 | ``` 167 | 168 | 输入： 169 | 170 | ``` 171 | Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure. 172 | ``` 173 | 174 | 输出： 175 | 176 | ``` 177 | e 出现了 27 次. 178 | n 出现了 21 次. 179 | a 出现了 18 次. 180 | i 出现了 18 次. 181 | s 出现了 16 次. 182 | t 出现了 16 次. 183 | o 出现了 14 次. 184 | h 出现了 13 次. 185 | r 出现了 10 次. 186 | d 出现了 9 次. 187 | l 出现了 9 次. 188 | g 出现了 6 次. 189 | u 出现了 6 次. 190 | f 出现了 6 次. 191 | c 出现了 6 次. 192 | y 出现了 5 次. 193 | b 出现了 5 次. 194 | m 出现了 4 次. 195 | p 出现了 3 次. 196 | w 出现了 2 次. 197 | v 出现了 2 次. 198 | M 出现了 1 次. 199 | k 出现了 1 次. 200 | x 出现了 1 次. 201 | ``` 202 | 203 | **例子2**：在一个字典中保存了股票的代码和价格，找出股价大于100元的股票并创建一个新的字典。 204 | 205 | > **说明**：可以用字典的生成式语法来创建这个新字典。 206 | 207 | ```Python 208 | stocks = { 209 | 'AAPL': 191.88, 210 | 'GOOG': 1186.96, 211 | 'IBM': 149.24, 212 | 'ORCL': 48.44, 213 | 'ACN': 166.89, 214 | 'FB': 208.09, 215 | 'SYMC': 21.29 216 | } 217 | stocks2 = {key: value for key, value in stocks.items() if value > 100} 218 | print(stocks2) 219 | ``` 220 | 221 | 输出： 222 | 223 | ``` 224 | {'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ACN': 166.89, 'FB': 208.09} 225 | ``` 226 | 227 | ### 总结 228 | 229 | Python 程序中的字典跟现实生活中字典非常像，允许我们**以键值对的形式保存数据**，再**通过键索引对应的值**。这是一种非常**有利于数据检索**的数据类型。再次提醒大家注意，**字典中的键必须是不可变类型**，字典中的值可以是任意类型。 230 | -------------------------------------------------------------------------------- /第14课：函数和模块.md: -------------------------------------------------------------------------------- 1 | ## 第14课：函数和模块 2 | 3 | 在讲解本节课的内容之前，我们先来研究一道数学题，请说出下面的方程有多少组正整数解。 4 | $$ 5 | x_1 + x_2 + x_3 + x_4 = 8 6 | $$ 7 | 8 | 你可能已经想到了，这个问题其实等同于将8个苹果分成四组且每组至少一个苹果有多少种方案，也等价于在分隔8个苹果的7个间隙之间放入三个隔断将苹果分成四组有多少种方案，所以答案是$ C_7^3=35 $，其中，$C_{7}^{3}$代表7选3的组合数，其计算公式如下所示。 9 | $$ 10 | C_m^n = \frac {m!} {n!(m-n)!} 11 | $$ 12 | 13 | 14 | 根据之前学习的知识，我们可以用循环做累乘的方式分别计算出$m!$、$n!$和$(m-n)!$，然后再通过除法运算得到组合数$C_m^n$，代码如下所示。 15 | 16 | ```python 17 | """ 18 | 输入m和n，计算组合数C(m,n)的值 19 | 20 | Version: 1.0 21 | Author: 骆昊 22 | """ 23 | 24 | m = int(input('m = ')) 25 | n = int(input('n = ')) 26 | # 计算m的阶乘 27 | fm = 1 28 | for num in range(1, m + 1): 29 | fm *= num 30 | # 计算n的阶乘 31 | fn = 1 32 | for num in range(1, n + 1): 33 | fn *= num 34 | # 计算m-n的阶乘 35 | fk = 1 36 | for num in range(1, m - n + 1): 37 | fk *= num 38 | # 计算C(M,N)的值 39 | print(fm // fn // fk) 40 | ``` 41 | 42 | 输入： 43 | 44 | ``` 45 | m = 7 46 | n = 3 47 | ``` 48 | 49 | 输出： 50 | 51 | ``` 52 | 35 53 | ``` 54 | 55 | 不知大家是否注意到，上面的代码中我们做了三次求阶乘的操作，虽然$m$、$n$、$m - n$的值各不相同，但是三段代码并没有实质性的区别，属于重复代码。世界级的编程大师*Martin Fowler*曾经说过：“**代码有很多种坏味道，重复是最坏的一种！**”。要写出高质量的代码，首先就要解决重复代码的问题。对于上面的代码来说，我们可以将求阶乘的功能封装到一个称为“函数”的代码块中，在需要计算阶乘的地方，我们只需“调用函数”即可实现对求阶乘功能的复用。 56 | 57 | ### 定义函数 58 | 59 | 数学上的函数通常形如$y = f(x)$或者$z = g(x, y)$这样的形式，在$y = f(x)$中，$f$是函数的名字，$x$是函数的自变量，$y$是函数的因变量；而在$z = g(x, y)$中，$g$是函数名，$x$和$y$是函数的自变量，$z$是函数的因变量。Python 中的函数跟这个结构是一致的，每个函数都有自己的名字、自变量和因变量。我们通常把 Python 函数的自变量称为函数的参数，而因变量称为函数的返回值。 60 | 61 | Python 中可以使用`def`关键字来定义函数，和变量一样每个函数也应该有一个漂亮的名字，命名规则跟变量的命名规则是一样的（大家赶紧想想我们之前讲过的变量的命名规则）。在函数名后面的圆括号中可以设置函数的参数，也就是我们刚才说的函数的自变量，而函数执行完成后，我们会通过`return`关键字来返回函数的执行结果，这就是我们刚才说的函数的因变量。如果函数中没有`return`语句，那么函数会返回代表空值的`None`。另外，函数也可以没有自变量（参数），但是函数名后面的圆括号是必须有的。一个函数要做的事情（要执行的代码），是通过代码缩进的方式放到函数定义行之后，跟之前分支和循环结构的代码块类似，如下图所示。 62 | 63 | 64 | 65 | 下面，我们将之前代码中求阶乘的操作放到一个函数中，通过这种方式来重构上面的代码。**所谓重构，是在不影响代码执行结果的前提下对代码的结构进行调整**，重构之后的代码如下所示。 66 | 67 | ```python 68 | """ 69 | 输入m和n，计算组合数C(m,n)的值 70 | 71 | Version: 1.1 72 | Author: 骆昊 73 | """ 74 | 75 | 76 | # 通过关键字def定义求阶乘的函数 77 | # 自变量（参数）num是一个非负整数 78 | # 因变量（返回值）是num的阶乘 79 | def fac(num): 80 | result = 1 81 | for n in range(2, num + 1): 82 | result *= n 83 | return result 84 | 85 | 86 | m = int(input('m = ')) 87 | n = int(input('n = ')) 88 | # 计算阶乘的时候不需要写重复的代码而是直接调用函数 89 | # 调用函数的语法是在函数名后面跟上圆括号并传入参数 90 | print(fac(m) // fac(n) // fac(m - n)) 91 | ``` 92 | 93 | 大家可以感受下，上面的代码是不是比之前的版本更加简单优雅。更为重要的是，我们定义的求阶乘函数`fac`还可以在其他需要求阶乘的代码中重复使用。所以，**使用函数可以帮助我们将功能上相对独立且会被重复使用的代码封装起来**，当我们需要这些的代码，不是把重复的代码再编写一遍，而是**通过调用函数实现对既有代码的复用**。事实上，Python 标准库的`math`模块中，已经有一个名为`factorial`的函数实现了求阶乘的功能，我们可以直接用`import math`导入`math`模块，然后使用`math.factorial`来调用求阶乘的函数；我们也可以通过`from math import factorial`直接导入`factorial`函数来使用它，代码如下所示。 94 | 95 | ```python 96 | """ 97 | 输入m和n，计算组合数C(m,n)的值 98 | 99 | Version: 1.2 100 | Author: 骆昊 101 | """ 102 | from math import factorial 103 | 104 | m = int(input('m = ')) 105 | n = int(input('n = ')) 106 | print(factorial(m) // factorial(n) // factorial(m - n)) 107 | ``` 108 | 109 | 将来我们使用的函数，要么是自定义的函数，要么是 Python 标准库或者三方库中提供的函数，如果已经有现成的可用的函数，我们就没有必要自己去定义，“**重复发明轮子**”是一件非常糟糕的事情。对于上面的代码，如果你觉得`factorial`这个名字太长，书写代码的时候不是特别方便，我们在导入函数的时候还可以通过`as`关键字为其别名。在调用函数的时候，我们可以用函数的别名，而不再使用它之前的名字，代码如下所示。 110 | 111 | ```python 112 | """ 113 | 输入m和n，计算组合数C(m,n)的值 114 | 115 | Version: 1.3 116 | Author: 骆昊 117 | """ 118 | from math import factorial as f 119 | 120 | m = int(input('m = ')) 121 | n = int(input('n = ')) 122 | print(f(m) // f(n) // f(m - n)) 123 | ``` 124 | 125 | ### 函数的参数 126 | 127 | #### 位置参数和关键字参数 128 | 129 | 我们再来写一个函数，根据给出的三条边的长度判断是否可以构成三角形，如果可以构成三角形则返回`True`，否则返回`False`，代码如下所示。 130 | 131 | ```python 132 | def make_judgement(a, b, c): 133 | """判断三条边的长度能否构成三角形""" 134 | return a + b > c and b + c > a and a + c > b 135 | ``` 136 | 137 | 上面`make_judgement`函数有三个参数，这种参数叫做位置参数，在调用函数时通常按照从左到右的顺序依次传入，而且传入参数的数量必须和定义函数时参数的数量相同，如下所示。 138 | 139 | ```python 140 | print(make_judgement(1, 2, 3)) # False 141 | print(make_judgement(4, 5, 6)) # True 142 | ``` 143 | 144 | 如果不想按照从左到右的顺序依次给出`a`、`b`、`c` 三个参数的值，也可以使用关键字参数，通过“参数名=参数值”的形式为函数传入参数，如下所示。 145 | 146 | ```python 147 | print(make_judgement(b=2, c=3, a=1)) # False 148 | print(make_judgement(c=6, b=4, a=5)) # True 149 | ``` 150 | 151 | 在定义函数时，我们可以在参数列表中用`/`设置**强制位置参数**（*positional-only arguments*），用`*`设置**命名关键字参数**。所谓强制位置参数，就是调用函数时只能按照参数位置来接收参数值的参数；而命名关键字参数只能通过“参数名=参数值”的方式来传递和接收参数，大家可以看看下面的例子。 152 | 153 | ```python 154 | # /前面的参数是强制位置参数 155 | def make_judgement(a, b, c, /): 156 | """判断三条边的长度能否构成三角形""" 157 | return a + b > c and b + c > a and a + c > b 158 | 159 | 160 | # 下面的代码会产生TypeError错误，错误信息提示“强制位置参数是不允许给出参数名的” 161 | # TypeError: make_judgement() got some positional-only arguments passed as keyword arguments 162 | # print(make_judgement(b=2, c=3, a=1)) 163 | ``` 164 | 165 | > **说明**：强制位置参数是 Python 3.8 引入的新特性，在使用低版本的 Python 解释器时需要注意。 166 | 167 | ```python 168 | # *后面的参数是命名关键字参数 169 | def make_judgement(*, a, b, c): 170 | """判断三条边的长度能否构成三角形""" 171 | return a + b > c and b + c > a and a + c > b 172 | 173 | 174 | # 下面的代码会产生TypeError错误，错误信息提示“函数没有位置参数但却给了3个位置参数” 175 | # TypeError: make_judgement() takes 0 positional arguments but 3 were given 176 | # print(make_judgement(1, 2, 3)) 177 | ``` 178 | 179 | #### 参数的默认值 180 | 181 | Python 中允许函数的参数拥有默认值，我们可以把之前讲过的一个例子“CRAPS赌博游戏”（《第07课：分支和循环结构的应用》）中摇色子获得点数的功能封装到函数中，代码如下所示。 182 | 183 | ```python 184 | from random import randrange 185 | 186 | 187 | # 定义摇色子的函数 188 | # 函数的自变量（参数）n表示色子的个数，默认值为2 189 | # 函数的因变量（返回值）表示摇n颗色子得到的点数 190 | def roll_dice(n=2): 191 | total = 0 192 | for _ in range(n): 193 | total += randrange(1, 7) 194 | return total 195 | 196 | 197 | # 如果没有指定参数，那么n使用默认值2，表示摇两颗色子 198 | print(roll_dice()) 199 | # 传入参数3，变量n被赋值为3，表示摇三颗色子获得点数 200 | print(roll_dice(3)) 201 | ``` 202 | 203 | 我们再来看一个更为简单的例子。 204 | 205 | ```python 206 | def add(a=0, b=0, c=0): 207 | """三个数相加求和""" 208 | return a + b + c 209 | 210 | 211 | # 调用add函数，没有传入参数，那么a、b、c都使用默认值0 212 | print(add()) # 0 213 | # 调用add函数，传入一个参数，该参数赋值给变量a, 变量b和c使用默认值0 214 | print(add(1)) # 1 215 | # 调用add函数，传入两个参数，分别赋值给变量a和b，变量c使用默认值0 216 | print(add(1, 2)) # 3 217 | # 调用add函数，传入三个参数，分别赋值给a、b、c三个变量 218 | print(add(1, 2, 3)) # 6 219 | ``` 220 | 221 | 需要注意的是，**带默认值的参数必须放在不带默认值的参数之后**，否则将产生`SyntaxError`错误，错误消息是：`non-default argument follows default argument`，翻译成中文的意思是“没有默认值的参数放在了带默认值的参数后面”。 222 | 223 | #### 可变参数 224 | 225 | Python 语言中可以通过星号表达式语法让函数支持可变参数。所谓可变参数指的是在调用函数时，可以向函数传入`0`个或任意多个参数。将来我们以团队协作的方式开发商业项目时，很有可能要设计函数给其他人使用，但有的时候我们并不知道函数的调用者会向该函数传入多少个参数，这个时候可变参数就能派上用场。 226 | 227 | 下面的代码演示了如何使用可变位置参数实现对任意多个数求和的`add`函数，调用函数时传入的参数会保存到一个元组，通过对该元组的遍历，可以获取传入函数的参数。 228 | 229 | ```python 230 | # 用星号表达式来表示args可以接收0个或任意多个参数 231 | # 调用函数时传入的n个参数会组装成一个n元组赋给args 232 | # 如果一个参数都没有传入，那么args会是一个空元组 233 | def add(*args): 234 | total = 0 235 | # 对保存可变参数的元组进行循环遍历 236 | for val in args: 237 | # 对参数进行了类型检查（数值型的才能求和） 238 | if type(val) in (int, float): 239 | total += val 240 | return total 241 | 242 | 243 | # 在调用add函数时可以传入0个或任意多个参数 244 | print(add()) # 0 245 | print(add(1)) # 1 246 | print(add(1, 2, 3)) # 6 247 | print(add(1, 2, 'hello', 3.45, 6)) # 12.45 248 | ``` 249 | 250 | 如果我们希望通过“参数名=参数值”的形式传入若干个参数，具体有多少个参数也是不确定的，我们还可以给函数添加可变关键字参数，把传入的关键字参数组装到一个字典中，代码如下所示。 251 | 252 | ```python 253 | # 参数列表中的**kwargs可以接收0个或任意多个关键字参数 254 | # 调用函数时传入的关键字参数会组装成一个字典（参数名是字典中的键，参数值是字典中的值） 255 | # 如果一个关键字参数都没有传入，那么kwargs会是一个空字典 256 | def foo(*args, **kwargs): 257 | print(args) 258 | print(kwargs) 259 | 260 | 261 | foo(3, 2.1, True, name='骆昊', age=43, gpa=4.95) 262 | ``` 263 | 264 | 输出： 265 | 266 | ``` 267 | (3, 2.1, True) 268 | {'name': '骆昊', 'age': 43, 'gpa': 4.95} 269 | ``` 270 | 271 | ### 用模块管理函数 272 | 273 | 不管用什么样的编程语言来写代码，给变量、函数起名字都是一个让人头疼的问题，因为我们会遇到**命名冲突**这种尴尬的情况。最简单的场景就是在同一个`.py`文件中定义了两个同名的函数，如下所示。 274 | 275 | ```python 276 | def foo(): 277 | print('hello, world!') 278 | 279 | 280 | def foo(): 281 | print('goodbye, world!') 282 | 283 | 284 | foo() # 大家猜猜调用foo函数会输出什么 285 | ``` 286 | 287 | 当然上面的这种情况我们很容易就能避免，但是如果项目是团队协作多人开发的时候，团队中可能有多个程序员都定义了名为`foo`的函数，这种情况下怎么解决命名冲突呢？答案其实很简单，Python 中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候，我们通过`import`关键字导入指定的模块再使用**完全限定名**（`模块名.函数名`）的调用方式，就可以区分到底要使用的是哪个模块中的`foo`函数，代码如下所示。 288 | 289 | `module1.py` 290 | 291 | ```python 292 | def foo(): 293 | print('hello, world!') 294 | ``` 295 | 296 | `module2.py` 297 | 298 | ```python 299 | def foo(): 300 | print('goodbye, world!') 301 | ``` 302 | 303 | `test.py` 304 | 305 | ```python 306 | import module1 307 | import module2 308 | 309 | # 用“模块名.函数名”的方式（完全限定名）调用函数， 310 | module1.foo() # hello, world! 311 | module2.foo() # goodbye, world! 312 | ``` 313 | 314 | 在导入模块时，还可以使用`as`关键字对模块进行别名，这样我们可以使用更为简短的完全限定名。 315 | 316 | `test.py` 317 | 318 | ```python 319 | import module1 as m1 320 | import module2 as m2 321 | 322 | m1.foo() # hello, world! 323 | m2.foo() # goodbye, world! 324 | ``` 325 | 326 | 上面两段代码，我们导入的是定义函数的模块，我们也可以使用`from...import...`语法从模块中直接导入需要使用的函数，代码如下所示。 327 | 328 | `test.py` 329 | 330 | ```python 331 | from module1 import foo 332 | 333 | foo() # hello, world! 334 | 335 | from module2 import foo 336 | 337 | foo() # goodbye, world! 338 | ``` 339 | 340 | 但是，如果我们如果从两个不同的模块中导入了同名的函数，后面导入的函数会替换掉之前的导入，就像下面的代码，调用`foo`会输出`goodbye, world!`，因为我们先导入了`module1`的`foo`，后导入了`module2`的`foo` 。如果两个`from...import...`反过来写，那就是另外一番光景了。 341 | 342 | `test.py` 343 | 344 | ```python 345 | from module1 import foo 346 | from module2 import foo 347 | 348 | foo() # goodbye, world! 349 | ``` 350 | 351 | 如果想在上面的代码中同时使用来自两个模块的`foo`函数还是有办法的，大家可能已经猜到了，还是用`as`关键字对导入的函数进行别名，代码如下所示。 352 | 353 | `test.py` 354 | 355 | ```python 356 | from module1 import foo as f1 357 | from module2 import foo as f2 358 | 359 | f1() # hello, world! 360 | f2() # goodbye, world! 361 | ``` 362 | 363 | ### 标准库中的模块和函数 364 | 365 | Python 标准库中提供了大量的模块和函数来简化我们的开发工作，我们之前用过的`random`模块就为我们提供了生成随机数和进行随机抽样的函数；而`time`模块则提供了和时间操作相关的函数；我们之前用到过的`math`模块中还包括了计算正弦、余弦、指数、对数等一系列的数学函数。随着我们深入学习 Python 语言，我们还会用到更多的模块和函数。 366 | 367 | Python 标准库中还有一类函数是不需要`import`就能够直接使用的，我们将其称之为**内置函数**，这些内置函数不仅有用而且还很常用，下面的表格列出了一部分的内置函数。 368 | 369 | | 函数 | 说明 | 370 | | ------- | ------------------------------------------------------------ | 371 | | `abs` | 返回一个数的绝对值，例如：`abs(-1.3)`会返回`1.3`。 | 372 | | `bin` | 把一个整数转换成以`'0b'`开头的二进制字符串，例如：`bin(123)`会返回`'0b1111011'`。 | 373 | | `chr` | 将Unicode编码转换成对应的字符，例如：`chr(8364)`会返回`'€'`。 | 374 | | `hex` | 将一个整数转换成以`'0x'`开头的十六进制字符串，例如：`hex(123)`会返回`'0x7b'`。 | 375 | | `input` | 从输入中读取一行，返回读到的字符串。 | 376 | | `len` | 获取字符串、列表等的长度。 | 377 | | `max` | 返回多个参数或一个可迭代对象中的最大值，例如：`max(12, 95, 37)`会返回`95`。 | 378 | | `min` | 返回多个参数或一个可迭代对象中的最小值，例如：`min(12, 95, 37)`会返回`12`。 | 379 | | `oct` | 把一个整数转换成以`'0o'`开头的八进制字符串，例如：`oct(123)`会返回`'0o173'`。 | 380 | | `open` | 打开一个文件并返回文件对象。 | 381 | | `ord` | 将字符转换成对应的Unicode编码，例如：`ord('€')`会返回`8364`。 | 382 | | `pow` | 求幂运算，例如：`pow(2, 3)`会返回`8`；`pow(2, 0.5)`会返回`1.4142135623730951`。 | 383 | | `print` | 打印输出。 | 384 | | `range` | 构造一个范围序列，例如：`range(100)`会产生`0`到`99`的整数序列。 | 385 | | `round` | 按照指定的精度对数值进行四舍五入，例如：`round(1.23456, 4)`会返回`1.2346`。 | 386 | | `sum` | 对一个序列中的项从左到右进行求和运算，例如：`sum(range(1, 101))`会返回`5050`。 | 387 | | `type` | 返回对象的类型，例如：`type(10)`会返回`int`；而` type('hello')`会返回`str`。 | 388 | 389 | ### 总结 390 | 391 | **函数是对功能相对独立且会重复使用的代码的封装**。学会使用定义和使用函数，就能够写出更为优质的代码。当然，Python 语言的标准库中已经为我们提供了大量的模块和常用的函数，用好这些模块和函数就能够用更少的代码做更多的事情；如果这些模块和函数不能满足我们的要求，可能就需要自定义函数，然后再通过模块的概念来管理这些自定义函数。 -------------------------------------------------------------------------------- /第15课：函数的应用.md: -------------------------------------------------------------------------------- 1 | ## 第15课：函数的应用 2 | 3 | ### 案例1 4 | 5 | 设计一个生成随机验证码的函数，验证码由数字和英文大小写字母构成，长度可以通过参数设置。 6 | 7 | ```python 8 | import random 9 | import string 10 | 11 | ALL_CHARS = string.digits + string.ascii_letters 12 | 13 | 14 | def generate_code(*, code_len=4): 15 | """ 16 | 生成指定长度的验证码 17 | :param code_len: 验证码的长度(默认4个字符) 18 | :return: 由大小写英文字母和数字构成的随机验证码字符串 19 | """ 20 | return ''.join(random.choices(ALL_CHARS, k=code_len)) 21 | ``` 22 | 23 | > **说明1**：`string`模块的`digits`代表0到9的数字构成的字符串`'0123456789'`，`string`模块的`ascii_letters`代表大小写英文字母构成的字符串`'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`。 24 | > 25 | > **说明2**：`random`模块的`sample`和`choices`函数都可以实现随机抽样，`sample`实现无放回抽样，这意味着抽样取出的元素是不重复的；`choices`实现有放回抽样，这意味着可能会重复选中某些元素。这两个函数的第一个参数代表抽样的总体，而参数`k`代表样本容量，需要说明的是`choices`函数的参数`k`是一个命名关键字参数，在传参时必须指定参数名。 26 | 27 | 可以用下面的代码生成5组随机验证码来测试上面的函数。 28 | 29 | ```python 30 | for _ in range(5): 31 | print(generate_code()) 32 | ``` 33 | 34 | 输出： 35 | 36 | ``` 37 | 59tZ 38 | QKU5 39 | izq8 40 | IBBb 41 | jIfX 42 | ``` 43 | 44 | 或者 45 | 46 | ```python 47 | for _ in range(5): 48 | print(generate_code(code_len=6)) 49 | ``` 50 | 51 | 输出： 52 | 53 | ``` 54 | FxJucw 55 | HS4H9G 56 | 0yyXfz 57 | x7fohf 58 | ReO22w 59 | ``` 60 | 61 | > **说明**：我们设计的`generate_code`函数的参数是命名关键字参数，由于它有默认值，可以不给它传值，使用默认值4。如果需要给函数传入参数，必须指定参数名`code_len`。 62 | 63 | ### 案例2 64 | 65 | 设计一个判断给定的大于1的正整数是不是质数的函数。质数是只能被1和自身整除的正整数（大于1），如果一个大于1的正整数$N$是质数，那就意味着在2到$N-1$之间都没有它的因子。 66 | 67 | ```python 68 | def is_prime(num: int) -> bool: 69 | """ 70 | 判断一个正整数是不是质数 71 | :param num: 大于1的正整数 72 | :return: 如果num是质数返回True，否则返回False 73 | """ 74 | for i in range(2, int(num ** 0.5) + 1): 75 | if num % i == 0: 76 | return False 77 | return True 78 | ``` 79 | 80 | > **说明1**：上面`is_prime`函数的参数`num`后面的`: int`用来标注参数的类型，虽然它对代码的执行结果不产生任何影响，但是很好的增强了代码的可读性。同理，参数列表后面的`-> bool`用来标注函数返回值的类型，它也不会对代码的执行结果产生影响，但是却让我们清楚的知道，调用函数会得到一个布尔值，要么是`True`，要么是`False`。 81 | > 82 | > **说明2**：上面的循环并不需要从2循环到$\small{N-1}$，因为如果循环进行到$\small{\sqrt{N}}$时，还没有找到$\small{N}$的因子，那么$\small{\sqrt{N}}$之后也不会出现$\small{N}$的因子，大家可以自己想一想这是为什么。 83 | 84 | ### 案例3 85 | 86 | 设计计算两个正整数最大公约数和最小公倍数的函数。$x$和$y$的最大公约数是能够同时整除$x$和$y$的最大整数，如果$x$和$y$互质，那么它们的最大公约数为1；$x$和$y$的最小公倍数是能够同时被$x$和$y$整除的最小正整数，如果$x$和$y$互质，那么它们的最小公倍数为$x \times y$。需要提醒大家注意的是，计算最大公约数和最小公倍数是两个不同的功能，应该设计成两个函数，而不是把两个功能放到同一个函数中。 87 | 88 | ```python 89 | def lcm(x: int, y: int) -> int: 90 | """求最小公倍数""" 91 | return x * y // gcd(x, y) 92 | 93 | 94 | def gcd(x: int, y: int) -> int: 95 | """求最大公约数""" 96 | while y % x != 0: 97 | x, y = y % x, x 98 | return x 99 | ``` 100 | 101 | > **说明1**：函数之间可以相互调用，上面求最小公倍数的`lcm`函数就调用了求最大公约数的`gcd`函数，通过$\frac{x \times y}{ gcd(x, y)}$来计算最小公倍数。 102 | > 103 | > **说明2**：上面的`gcd`函数使用了欧几里得算法计算最大公约数，欧几里得算法也称为辗转相除法，这个算法通常有更好的执行效率，不了解的小伙伴可以自行科普。 104 | 105 | ### 案例4 106 | 107 | 假设样本数据保存一个列表中，设计计算样本数据描述性统计信息的函数。描述性统计信息通常包括：算术平均值、中位数、极差（最大值和最小值的差）、方差、标准差、变异系数等，计算公式如下所示： 108 | 109 | 样本均值（sample mean）： 110 | $$ 111 | \bar{x} = \frac{\sum_{i=1}^{n}x_{i}}{n} = \frac{x_{1}+x_{2}+\cdots +x_{n}}{n} 112 | $$ 113 | 样本方差（sample variance）： 114 | $$ 115 | s^2 = \frac {\sum_{i=1}^{n}(x_i - \bar{x})^2} {n-1} 116 | $$ 117 | 样本标准差（sample standard deviation）： 118 | $$ 119 | s = \sqrt{\frac{\sum_{i=1}^{n}(x_i - \bar{x})^2}{n-1}} 120 | $$ 121 | 变异系数（coefficient of sample variation）： 122 | $$ 123 | CV = \frac{s}{\bar{x}} 124 | $$ 125 | 126 | ```python 127 | def ptp(data): 128 | """极差（全距）""" 129 | return max(data) - min(data) 130 | 131 | 132 | def mean(data): 133 | """算术平均""" 134 | return sum(data) / len(data) 135 | 136 | 137 | def median(data): 138 | """中位数""" 139 | temp, size = sorted(data), len(data) 140 | if size % 2 != 0: 141 | return temp[size // 2] 142 | else: 143 | return mean(temp[size // 2 - 1:size // 2 + 1]) 144 | 145 | 146 | def var(data, ddof=1): 147 | """方差""" 148 | x_bar = mean(data) 149 | temp = [(num - x_bar) ** 2 for num in data] 150 | return sum(temp) / (len(temp) - ddof) 151 | 152 | 153 | def std(data, ddof=1): 154 | """标准差""" 155 | return var(data, ddof) ** 0.5 156 | 157 | 158 | def cv(data, ddof=1): 159 | """变异系数""" 160 | return std(data, ddof) / mean(data) 161 | 162 | 163 | def describe(data): 164 | """输出描述性统计信息""" 165 | print(f'均值: {mean(data)}') 166 | print(f'中位数: {median(data)}') 167 | print(f'极差: {ptp(data)}') 168 | print(f'方差: {var(data)}') 169 | print(f'标准差: {std(data)}') 170 | print(f'变异系数: {cv(data)}') 171 | ``` 172 | 173 | > **说明1**：中位数是将数据按照升序或降序排列后位于中间的数，它描述了数据的中等水平。中位数的计算分两种情况：当数据体量$n$为奇数时，中位数是位于$\frac{n + 1}{2}$位置的元素；当数据体量$n$为偶数时，中位数是位于$\frac{n}{2}$和$\frac{n}{2} + 1$两个位置元素的均值。 174 | > 175 | > **说明2**：计算方差和标准差的函数中有一个名为`ddof`的参数，它代表了可以调整的自由度，默认值为1。在计算样本方差和样本标准差时，需要进行自由度校正；如果要计算总体方差和总体标准差，可以将`ddof`参数赋值为0，即不需要进行自由度校正。 176 | > 177 | > **说明3**：`describe`函数将上面封装好的统计函数组装到一起，用于输出数据的描述性统计信息。事实上，Python 标准库中有一个名为`statistics`的模块，它已经把获取描述性统计信息的函数封装好了，有兴趣的读者可以自行了解。 178 | 179 | ### 案例5 180 | 181 | 我们用函数重构之前讲过的双色球随机选号的例子（《第09课：常用数据结构之列表-2》），将生成随机号码和输出一组号码的功能分别封装到两个函数中，然后通过调用函数实现机选`N`注号码的功能。 182 | 183 | ```python 184 | """ 185 | 双色球随机选号程序 186 | 187 | Author: 骆昊 188 | Version: 1.3 189 | """ 190 | import random 191 | 192 | RED_BALLS = [i for i in range(1, 34)] 193 | BLUE_BALLS = [i for i in range(1, 17)] 194 | 195 | 196 | def choose(): 197 | """ 198 | 生成一组随机号码 199 | :return: 保存随机号码的列表 200 | """ 201 | selected_balls = random.sample(RED_BALLS, 6) 202 | selected_balls.sort() 203 | selected_balls.append(random.choice(BLUE_BALLS)) 204 | return selected_balls 205 | 206 | 207 | def display(balls): 208 | """ 209 | 格式输出一组号码 210 | :param balls: 保存随机号码的列表 211 | """ 212 | for ball in balls[:-1]: 213 | print(f'\033[031m{ball:0>2d}\033[0m', end=' ') 214 | print(f'\033[034m{balls[-1]:0>2d}\033[0m') 215 | 216 | 217 | n = int(input('生成几注号码: ')) 218 | for _ in range(n): 219 | display(choose()) 220 | ``` 221 | 222 | > **说明**：大家看看`display(choose())`这行代码，这里我们先通过`choose`函数获得一组随机号码，然后把`choose`函数的返回值作为`display`函数的参数，通过`display`函数将选中的随机号码显示出来。重构之后的代码逻辑非常清晰，代码的可读性更强了。如果有人为你封装了这两个函数，你仅仅是函数的调用者，其实你根本不用关心`choose`函数和`display`函数的内部实现，你只需要知道调用`choose`函数可以生成一组随机号码，而调用`display`函数传入一个列表，就可以输出这组号码。将来我们使用各种各样的 Python 三方库时，我们也根本不关注它们的底层实现，我们需要知道的仅仅是调用哪个函数可以解决问题。 223 | 224 | ### 总结 225 | 226 | 在写代码尤其是开发商业项目的时候，一定要有意识的**将相对独立且重复使用的功能封装成函数**，这样不管是自己还是团队的其他成员都可以通过调用函数的方式来使用这些功能，减少工作中那些重复且乏味的劳动。 227 | -------------------------------------------------------------------------------- /第16课：函数使用进阶.md: -------------------------------------------------------------------------------- 1 | ## 第16课：函数使用进阶 2 | 3 | 我们继续探索定义和使用函数的相关知识。通过前面的学习，我们知道了函数有自变量（参数）和因变量（返回值），自变量可以是任意的数据类型，因变量也可以是任意的数据类型，那么这里就有一个小问题，我们能不能用函数作为函数的参数，用函数作为函数的返回值？这里我们先说结论：**Python 中的函数是“一等函数”**，所谓“一等函数”指的就是函数可以赋值给变量，函数可以作为函数的参数，函数也可以作为函数的返回值。把一个函数作为其他函数的参数或返回值的用法，我们通常称之为“高阶函数”。 4 | 5 | ### 高阶函数 6 | 7 | 我们回到之前讲过的一个例子，设计一个函数，传入任意多个参数，对其中`int`类型或`float`类型的元素实现求和操作。我们对之前的代码稍作调整，让整个代码更加紧凑一些，如下所示。 8 | 9 | ```Python 10 | def calc(*args, **kwargs): 11 | items = list(args) + list(kwargs.values()) 12 | result = 0 13 | for item in items: 14 | if type(item) in (int, float): 15 | result += item 16 | return result 17 | ``` 18 | 19 | 如果我们希望上面的`calc`函数不仅仅可以做多个参数的求和，还可以实现更多的甚至是自定义的二元运算，我们该怎么做呢？上面的代码只能求和是因为函数中使用了`+=`运算符，这使得函数跟加法运算形成了耦合关系，如果能解除这种耦合关系，函数的通用性和灵活性就会更好。解除耦合的办法就是将`+`运算符变成函数调用，并将其设计为函数的参数，代码如下所示。 20 | 21 | ```Python 22 | def calc(init_value, op_func, *args, **kwargs): 23 | items = list(args) + list(kwargs.values()) 24 | result = init_value 25 | for item in items: 26 | if type(item) in (int, float): 27 | result = op_func(result, item) 28 | return result 29 | ``` 30 | 31 | 注意，上面的函数增加了两个参数，其中`init_value`代表运算的初始值，`op_func`代表二元运算函数，为了调用修改后的函数，我们先定义做加法和乘法运算的函数，代码如下所示。 32 | 33 | ```python 34 | def add(x, y): 35 | return x + y 36 | 37 | 38 | def mul(x, y): 39 | return x * y 40 | ``` 41 | 42 | 如果要做求和的运算，我们可以按照下面的方式调用`calc`函数。 43 | 44 | ```python 45 | print(calc(0, add, 1, 2, 3, 4, 5)) # 15 46 | ``` 47 | 48 | 如果要做求乘积运算，我们可以按照下面的方式调用`calc`函数。 49 | 50 | ```python 51 | print(calc(1, mul, 1, 2, 3, 4, 5)) # 120 52 | ``` 53 | 54 | 上面的`calc`函数通过将运算符变成函数的参数，实现了跟加法运算耦合，这是一种非常高明和实用的编程技巧，但对于最初学者来说可能会觉得难以理解，建议大家细品一下。需要注意上面的代码中，将函数作为参数传入其他函数和直接调用函数是有显著的区别的，**调用函数需要在函数名后面跟上圆括号，而把函数作为参数时只需要函数名即可**。 55 | 56 | 如果我们没有提前定义好`add`和`mul`函数，也可以使用 Python 标准库中的`operator`模块提供的`add`和`mul`函数，它们分别代表了做加法和做乘法的二元运算，我们拿过来直接使用即可，代码如下所示。 57 | 58 | ```Python 59 | import operator 60 | 61 | print(calc(0, operator.add, 1, 2, 3, 4, 5)) # 15 62 | print(calc(1, operator.mul, 1, 2, 3, 4, 5)) # 120 63 | ``` 64 | 65 | Python 内置函数中有不少高阶函数，我们前面提到过的`filter`和`map`函数就是高阶函数，前者可以实现对序列中元素的过滤，后者可以实现对序列中元素的映射，例如我们要去掉一个整数列表中的奇数，并对所有的偶数求平方得到一个新的列表，就可以直接使用这两个函数来做到，具体的做法是如下所示。 66 | 67 | ```Python 68 | def is_even(num): 69 | """判断num是不是偶数""" 70 | return num % 2 == 0 71 | 72 | 73 | def square(num): 74 | """求平方""" 75 | return num ** 2 76 | 77 | 78 | old_nums = [35, 12, 8, 99, 60, 52] 79 | new_nums = list(map(square, filter(is_even, old_nums))) 80 | print(new_nums) # [144, 64, 3600, 2704] 81 | ``` 82 | 83 | 当然，要完成上面代码的功能，也可以使用列表生成式，列表生成式的做法更为简单优雅。 84 | 85 | ```Python 86 | old_nums = [35, 12, 8, 99, 60, 52] 87 | new_nums = [num ** 2 for num in old_nums if num % 2 == 0] 88 | print(new_nums) # [144, 64, 3600, 2704] 89 | ``` 90 | 91 | 我们再来讨论一个内置函数`sorted`，它可以实现对容器型数据类型（如：列表、字典等）元素的排序。我们之前讲过`list`类型的`sort`方法，它实现了对列表元素的排序，`sorted`函数从功能上来讲跟列表的`sort`方法没有区别，但它会返回排序后的列表对象，而不是直接修改原来的列表，这一点我们称为**函数的无副作用设计**，也就是说调用函数除了产生返回值以外，不会对程序的状态或外部环境产生任何其他的影响。使用`sorted`函数排序时，可以通过高阶函数的形式自定义排序的规则，我们通过下面的例子加以说明。 92 | 93 | ```python 94 | old_strings = ['in', 'apple', 'zoo', 'waxberry', 'pear'] 95 | new_strings = sorted(old_strings) 96 | print(new_strings) # ['apple', 'in', 'pear', waxberry', 'zoo'] 97 | ``` 98 | 99 | 上面的代码对大家来说并不陌生，但是如果希望根据字符串的长度而不是字母表顺序对列表元素排序，我们可以向`sorted`函数传入一个名为`key`的参数，将`key`参数赋值为获取字符串长度的函数`len`，这个函数我们在之前的课程中讲到过，代码如下所示。 100 | 101 | ```python 102 | old_strings = ['in', 'apple', 'zoo', 'waxberry', 'pear'] 103 | new_strings = sorted(old_strings, key=len) 104 | print(new_strings) # ['in', 'zoo', 'pear', 'apple', 'waxberry'] 105 | ``` 106 | 107 | > **说明**：列表类型的`sort`方法也有同样的`key`参数，有兴趣的读者可以自行尝试。 108 | 109 | ### Lambda函数 110 | 111 | 在使用高阶函数的时候，如果作为参数或者返回值的函数本身非常简单，一行代码就能够完成，也不需要考虑对函数的复用，那么我们可以使用 lambda 函数。Python 中的 lambda 函数是没有的名字函数，所以很多人也把它叫做**匿名函数**，lambda 函数只能有一行代码，代码中的表达式产生的运算结果就是这个匿名函数的返回值。之前的代码中，我们写的`is_even`和`square`函数都只有一行代码，我们可以考虑用 lambda 函数来替换掉它们，代码如下所示。 112 | 113 | ```Python 114 | old_nums = [35, 12, 8, 99, 60, 52] 115 | new_nums = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, old_nums))) 116 | print(new_nums) # [144, 64, 3600, 2704] 117 | ``` 118 | 119 | 通过上面的代码可以看出，定义 lambda 函数的关键字是`lambda`，后面跟函数的参数，如果有多个参数用逗号进行分隔；冒号后面的部分就是函数的执行体，通常是一个表达式，表达式的运算结果就是 lambda 函数的返回值，不需要写`return` 关键字。 120 | 121 | 前面我们说过，Python 中的函数是“一等函数”，函数是可以直接赋值给变量的。在学习了 lambda 函数之后，前面我们写过的一些函数就可以用一行代码来实现它们了，大家可以看看能否理解下面的求阶乘和判断素数的函数。 122 | 123 | ```Python 124 | import functools 125 | import operator 126 | 127 | # 用一行代码实现计算阶乘的函数 128 | fac = lambda n: functools.reduce(operator.mul, range(2, n + 1), 1) 129 | 130 | # 用一行代码实现判断素数的函数 131 | is_prime = lambda x: all(map(lambda f: x % f, range(2, int(x ** 0.5) + 1))) 132 | 133 | # 调用Lambda函数 134 | print(fac(6)) # 720 135 | print(is_prime(37)) # True 136 | ``` 137 | 138 | > **提示1**：上面使用的`reduce`函数是 Python 标准库`functools`模块中的函数，它可以实现对一组数据的归约操作，类似于我们之前定义的`calc`函数，第一个参数是代表运算的函数，第二个参数是运算的数据，第三个参数是运算的初始值。很显然，`reduce`函数也是高阶函数，它和`filter`函数、`map`函数一起构成了处理数据中非常关键的三个动作：**过滤**、**映射**和**归约**。 139 | > 140 | > **提示2**：上面判断素数的 lambda 函数通过`range`函数构造了从$\small{2}$到$\small{\sqrt{x}}$的范围，检查这个范围有没有`x`的因子。`all`函数也是 Python 内置函数，如果传入的序列中所有的布尔值都是`True`，`all`函数返回`True`，否则`all`函数返回`False`。 141 | 142 | ### 偏函数 143 | 144 | 偏函数是指固定函数的某些参数，生成一个新的函数，这样就无需在每次调用函数时都传递相同的参数。在 Python 语言中，我们可以使用`functools`模块的`partial`函数来创建偏函数。例如，`int`函数在默认情况下可以将字符串视为十进制整数进行类型转换，如果我们修修改它的`base`参数，就可以定义出三个新函数，分别用于将二进制、八进制、十六进制字符串转换为整数，代码如下所示。 145 | 146 | ```python 147 | import functools 148 | 149 | int2 = functools.partial(int, base=2) 150 | int8 = functools.partial(int, base=8) 151 | int16 = functools.partial(int, base=16) 152 | 153 | print(int('1001')) # 1001 154 | 155 | print(int2('1001')) # 9 156 | print(int8('1001')) # 513 157 | print(int16('1001')) # 4097 158 | ``` 159 | 160 | 不知大家是否注意到，`partial`函数的第一个参数和返回值都是函数，它将传入的函数处理成一个新的函数返回。通过构造偏函数，我们可以结合实际的使用场景将原函数变成使用起来更为便捷的新函数，不知道大家有没有觉得这波操作很有意思。 161 | 162 | ### 总结 163 | 164 | Python 中的函数是一等函数，可以赋值给变量，也可以作为函数的参数和返回值，这也就意味着我们可以在 Python 中使用高阶函数。高阶函数的概念对新手并不友好，但它却带来了函数设计上的灵活性。如果我们要定义的函数非常简单，只有一行代码，而且不需要函数名来复用它，我们可以使用 lambda 函数。 165 | 166 | -------------------------------------------------------------------------------- /第17课：函数高级应用.md: -------------------------------------------------------------------------------- 1 | ## 第17课：函数高级应用 2 | 3 | 在上一个章节中，我们探索了 Python 中的高阶函数，相信大家对函数的定义和应用有了更深刻的认知。本章我们继续为大家讲解函数相关的知识，一个是 Python 中的特色语法装饰器，一个是函数的递归调用。 4 | 5 | ### 装饰器 6 | 7 | Python 语言中，装饰器是“**用一个函数装饰另外一个函数并为其提供额外的能力**”的语法现象。装饰器本身是一个函数，它的参数是被装饰的函数，它的返回值是一个带有装饰功能的函数。通过前面的描述，相信大家已经听出来了，装饰器是一个高阶函数，它的参数和返回值都是函数。但是，装饰器的概念对编程语言的初学者来说，还是让人头疼的，下面我们先通过一个简单的例子来说明装饰器的作用。假设有名为`downlaod`和`upload`的两个函数，分别用于文件的上传和下载，如下所示。 8 | 9 | ```Python 10 | import random 11 | import time 12 | 13 | 14 | def download(filename): 15 | """下载文件""" 16 | print(f'开始下载{filename}.') 17 | time.sleep(random.random() * 6) 18 | print(f'{filename}下载完成.') 19 | 20 | 21 | def upload(filename): 22 | """上传文件""" 23 | print(f'开始上传{filename}.') 24 | time.sleep(random.random() * 8) 25 | print(f'{filename}上传完成.') 26 | 27 | 28 | download('MySQL从删库到跑路.avi') 29 | upload('Python从入门到住院.pdf') 30 | ``` 31 | 32 | > **说明**：上面的代码用休眠一段随机时间的方式模拟了下载和上传文件需要花费一定的时间，并没有真正的联网上传下载文件。用 Python 语言实现联网上传下载文件也非常简单，后面我们会讲到相关的知识。 33 | 34 | 现在有一个新的需求，我们希望知道调用`download`和`upload`函数上传下载文件到底用了多少时间，这应该如何实现呢？相信很多小伙伴已经想到了，我们可以在函数开始执行的时候记录一个时间，在函数调用结束后记录一个时间，两个时间相减就可以计算出下载或上传的时间，代码如下所示。 35 | 36 | ```Python 37 | start = time.time() 38 | download('MySQL从删库到跑路.avi') 39 | end = time.time() 40 | print(f'花费时间: {end - start:.2f}秒') 41 | start = time.time() 42 | upload('Python从入门到住院.pdf') 43 | end = time.time() 44 | print(f'花费时间: {end - start:.2f}秒') 45 | ``` 46 | 47 | 通过上面的代码，我们可以在下载和上传文件时记录下耗费的时间，但不知道大家是否注意到，上面记录时间、计算和显示执行时间的代码都是重复代码。有编程经验的人都知道，**重复的代码是万恶之源**，那么有没有办法在不写重复代码的前提下，用一种简单优雅的方式记录下函数的执行时间呢？在 Python 语言中，装饰器就是解决这类问题的最佳选择。通过装饰器语法，我们可以把跟原来的业务（上传和下载）没有关系计时功能的代码封装到一个函数中，如果`upload`和`download`函数需要记录时间，我们直接把装饰器作用到这两个函数上即可。既然上面提到了，装饰器是一个高阶函数，它的参数和返回值都是函数，我们将记录时间的装饰器姑且命名为`record_time`，那么它的整体结构应该如下面的代码所示。 48 | 49 | ```python 50 | def record_time(func): 51 | 52 | def wrapper(*args, **kwargs): 53 | 54 | result = func(*args, **kwargs) 55 | 56 | return result 57 | 58 | return wrapper 59 | ``` 60 | 61 | 相信大家注意到了，`record_time`函数的参数`func`代表了一个被装饰的函数，函数里面定义的`wrapper`函数是带有装饰功能的函数，它会执行被装饰的函数`func`，它还需要返回在最后产生函数执行的返回值。不知大家是否留意到，上面的代码我在第4行和第6行留下了两个空行，这意味着我们可以这些地方添加代码来实现额外的功能。`record_time`函数最终会返回这个带有装饰功能的函数`wrapper`并通过它替代原函数`func`，当原函数`func`被`record_time`函数装饰后，我们调用它时其实调用的是`wrapper`函数，所以才获得了额外的能力。`wrapper`函数的参数比较特殊，由于我们要用`wrapper`替代原函数`func`，但是我们又不清楚原函数`func`会接受哪些参数，所以我们就通过可变参数和关键字参数照单全收，然后在调用`func`的时候，原封不动的全部给它。这里还要强调一下，Python 语言支持函数的嵌套定义，就像上面，我们可以在`record_time`函数中定义`wrapper`函数，这个操作在很多编程语言中并不被支持。 62 | 63 | 看懂这个结构后，我们就可以把记录时间的功能写到这个装饰器中，代码如下所示。 64 | 65 | ```Python 66 | import time 67 | 68 | 69 | def record_time(func): 70 | 71 | def wrapper(*args, **kwargs): 72 | # 在执行被装饰的函数之前记录开始时间 73 | start = time.time() 74 | # 执行被装饰的函数并获取返回值 75 | result = func(*args, **kwargs) 76 | # 在执行被装饰的函数之后记录结束时间 77 | end = time.time() 78 | # 计算和显示被装饰函数的执行时间 79 | print(f'{func.__name__}执行时间: {end - start:.2f}秒') 80 | # 返回被装饰函数的返回值 81 | return result 82 | 83 | return wrapper 84 | ``` 85 | 86 | 写装饰器虽然颇费周折，但是这是个一劳永逸的骚操作，将来再有记录函数执行时间的需求时，我们只需要添加上面的装饰器即可。使用上面的装饰器函数有两种方式，第一种方式就是直接调用装饰器函数，传入被装饰的函数并获得返回值，我们可以用这个返回值直接替代原来的函数，那么在调用时就已经获得了装饰器提供的额外的能力（记录执行时间），大家试试下面的代码就明白了。 87 | 88 | ```Python 89 | download = record_time(download) 90 | upload = record_time(upload) 91 | download('MySQL从删库到跑路.avi') 92 | upload('Python从入门到住院.pdf') 93 | ``` 94 | 95 | 在 Python 中，使用装饰器很有更为便捷的**语法糖**（编程语言中添加的某种语法，这种语法对语言的功能没有影响，但是使用更加方法，代码的可读性也更强，我们将其称之为“语法糖”或“糖衣语法”），可以用`@装饰器函数`将装饰器函数直接放在被装饰的函数上，效果跟上面的代码相同。我们把完整的代码为大家罗列出来，大家可以再看看我们是如何定义和使用装饰器的。 96 | 97 | ```Python 98 | import random 99 | import time 100 | 101 | 102 | def record_time(func): 103 | 104 | def wrapper(*args, **kwargs): 105 | start = time.time() 106 | result = func(*args, **kwargs) 107 | end = time.time() 108 | print(f'{func.__name__}执行时间: {end - start:.2f}秒') 109 | return result 110 | 111 | return wrapper 112 | 113 | 114 | @record_time 115 | def download(filename): 116 | print(f'开始下载{filename}.') 117 | time.sleep(random.random() * 6) 118 | print(f'{filename}下载完成.') 119 | 120 | 121 | @record_time 122 | def upload(filename): 123 | print(f'开始上传{filename}.') 124 | time.sleep(random.random() * 8) 125 | print(f'{filename}上传完成.') 126 | 127 | 128 | download('MySQL从删库到跑路.avi') 129 | upload('Python从入门到住院.pdf') 130 | ``` 131 | 132 | 上面的代码，我们通过装饰器语法糖为`download`和`upload`函数添加了装饰器，被装饰后的`download`和`upload`函数其实就是我们在装饰器中返回的`wrapper`函数，调用它们其实就是在调用`wrapper`函数，所以才有了记录函数执行时间的功能。 133 | 134 | 如果在代码的某些地方，我们想去掉装饰器的作用执行原函数，那么在定义装饰器函数的时候，需要做一点点额外的工作。Python 标准库`functools`模块的`wraps`函数也是一个装饰器，我们将它放在`wrapper`函数上，这个装饰器可以帮我们保留被装饰之前的函数，这样在需要取消装饰器时，可以通过被装饰函数的`__wrapped__`属性获得被装饰之前的函数。 135 | 136 | ```Python 137 | import random 138 | import time 139 | 140 | from functools import wraps 141 | 142 | 143 | def record_time(func): 144 | 145 | @wraps(func) 146 | def wrapper(*args, **kwargs): 147 | start = time.time() 148 | result = func(*args, **kwargs) 149 | end = time.time() 150 | print(f'{func.__name__}执行时间: {end - start:.2f}秒') 151 | return result 152 | 153 | return wrapper 154 | 155 | 156 | @record_time 157 | def download(filename): 158 | print(f'开始下载{filename}.') 159 | time.sleep(random.random() * 6) 160 | print(f'{filename}下载完成.') 161 | 162 | 163 | @record_time 164 | def upload(filename): 165 | print(f'开始上传{filename}.') 166 | time.sleep(random.random() * 8) 167 | print(f'{filename}上传完成.') 168 | 169 | 170 | # 调用装饰后的函数会记录执行时间 171 | download('MySQL从删库到跑路.avi') 172 | upload('Python从入门到住院.pdf') 173 | # 取消装饰器的作用不记录执行时间 174 | download.__wrapped__('MySQL必知必会.pdf') 175 | upload.__wrapped__('Python从新手到大师.pdf') 176 | ``` 177 | 178 | **装饰器函数本身也可以参数化**，简单的说就是装饰器也是可以通过调用者传入的参数来进行定制的，这个知识点我们在后面用到的时候再为大家讲解。 179 | 180 | ### 递归调用 181 | 182 | Python 中允许函数嵌套定义，也允许函数之间相互调用，而且一个函数还可以直接或间接的调用自身。函数自己调用自己称为递归调用，那么递归调用有什么用处呢？现实中，有很多问题的定义本身就是一个递归定义，例如我们之前讲到的阶乘，非负整数`N`的阶乘是`N`乘以`N-1`的阶乘，即$\small{N! = N \times (N-1)!}$，定义的左边和右边都出现了阶乘的概念，所以这是一个递归定义。既然如此，我们可以使用递归调用的方式来写一个求阶乘的函数，代码如下所示。 183 | 184 | ```Python 185 | def fac(num): 186 | if num in (0, 1): 187 | return 1 188 | return num * fac(num - 1) 189 | ``` 190 | 191 | 上面的代码中，`fac`函数中又调用了`fac`函数，这就是所谓的递归调用。代码第2行的`if`条件叫做递归的收敛条件，简单的说就是什么时候要结束函数的递归调用，在计算阶乘时，如果计算到`0`或`1`的阶乘，就停止递归调用，直接返回`1`；代码第4行的`num * fac(num - 1)`是递归公式，也就是阶乘的递归定义。下面，我们简单的分析下，如果用`fac(5)`计算`5`的阶乘，整个过程会是怎样的。 192 | 193 | ```Python 194 | # 递归调用函数入栈 195 | # 5 * fac(4) 196 | # 5 * (4 * fac(3)) 197 | # 5 * (4 * (3 * fac(2))) 198 | # 5 * (4 * (3 * (2 * fac(1)))) 199 | # 停止递归函数出栈 200 | # 5 * (4 * (3 * (2 * 1))) 201 | # 5 * (4 * (3 * 2)) 202 | # 5 * (4 * 6) 203 | # 5 * 24 204 | # 120 205 | print(fac(5)) # 120 206 | ``` 207 | 208 | 注意，函数调用会通过内存中称为“栈”（stack）的数据结构来保存当前代码的执行现场，函数调用结束后会通过这个栈结构恢复之前的执行现场。栈是一种先进后出的数据结构，这也就意味着最早入栈的函数最后才会返回，而最后入栈的函数会最先返回。例如调用一个名为`a`的函数，函数`a`的执行体中又调用了函数`b`，函数`b`的执行体中又调用了函数`c`，那么最先入栈的函数是`a`，最先出栈的函数是`c`。每进入一个函数调用，栈就会增加一层栈帧（stack frame），栈帧就是我们刚才提到的保存当前代码执行现场的结构；每当函数调用结束后，栈就会减少一层栈帧。通常，内存中的栈空间很小，因此递归调用的次数如果太多，会导致栈溢出（stack overflow），所以**递归调用一定要确保能够快速收敛**。我们可以尝试执行`fac(5000)`，看看是不是会提示`RecursionError`错误，错误消息为：`maximum recursion depth exceeded in comparison`（超出最大递归深度），其实就是发生了栈溢出。 209 | 210 | 如果我们使用官方的 Python 解释器（CPython），默认将函数调用的栈结构最大深度设置为`1000`层。如果超出这个深度，就会发生上面说的`RecursionError`。当然，我们可以使用`sys`模块的`setrecursionlimit`函数来改变递归调用的最大深度，但是我们不建议这样做，因为让递归快速收敛才是我们应该做的事情，否则就应该考虑使用循环递推而不是递归。 211 | 212 | 再举一个之前讲过的生成斐波那契数列的例子，因为斐波那契数列前两个数都是`1`，从第三个数开始，每个数是前两个数相加的和，可以记为`f(n) = f(n - 1) + f(n - 2)`，很显然这又是一个递归的定义，所以我们可以用下面的递归调用函数来计算第​`n`个斐波那契数。 213 | 214 | ```Python 215 | def fib1(n): 216 | if n in (1, 2): 217 | return 1 218 | return fib1(n - 1) + fib1(n - 2) 219 | 220 | 221 | for i in range(1, 21): 222 | print(fib1(i)) 223 | ``` 224 | 225 | 需要提醒大家，上面计算斐波那契数的代码虽然看起来非常简单明了，但执行性能是比较糟糕的。大家可以试一试，把上面代码`for`循环中`range`函数的第二个参数修改为`51`，即输出前50个斐波那契数，看看需要多长时间，也欢迎大家在评论区留下你的代码执行时间。至于为什么这么慢，大家可以自己思考一下原因。很显然，直接使用循环递推的方式获得斐波那契数列是更好的选择，代码如下所示。 226 | 227 | ```Python 228 | def fib2(n): 229 | a, b = 0, 1 230 | for _ in range(n): 231 | a, b = b, a + b 232 | return a 233 | ``` 234 | 235 | 除此以外，我们还可以使用 Python 标准库中`functools`模块的`lru_cache`函数来优化上面的递归代码。`lru_cache`函数是一个装饰器函数，我们将其置于上面的函数`fib1`之上，它可以缓存该函数的执行结果从而避免在递归调用的过程中产生大量的重复运算，这样代码的执行性能就有“飞一般”的提升。大家可以尝试输出前50个斐波那契数，看看加上装饰器以后代码需要执行多长时间，评论区见！ 236 | 237 | ```python 238 | from functools import lru_cache 239 | 240 | 241 | @lru_cache() 242 | def fib1(n): 243 | if n in (1, 2): 244 | return 1 245 | return fib1(n - 1) + fib1(n - 2) 246 | 247 | 248 | for i in range(1, 51): 249 | print(i, fib1(i)) 250 | ``` 251 | 252 | > **提示**：`lru_cache`函数是一个带参数的装饰器，所以上面第4行代码使用装饰器语法糖时，`lru_cache`后面要跟上圆括号。`lru_cache`函数有一个非常重要的参数叫`maxsize`，它可以用来定义缓存空间的大小，默认值是128。 253 | 254 | ### 总结 255 | 256 | 装饰器是 Python 语言中的特色语法，**可以通过装饰器来增强现有的函数**，这是一种非常有用的编程技巧。另一方面，通过函数递归调用，可以在代码层面将一些复杂的问题简单化，但是**递归调用一定要注意收敛条件和递归公式**，找到递归公式才有机会使用递归调用，而收敛条件则确保了递归调用能停下来。函数调用通过内存中的栈空间来保存现场和恢复现场，栈空间通常都很小，所以**递归如果不能迅速收敛，很可能会引发栈溢出错误，从而导致程序的崩溃**。 257 | -------------------------------------------------------------------------------- /第18课：面向对象编程入门.md: -------------------------------------------------------------------------------- 1 | ## 第18课：面向对象编程入门 2 | 3 | 面向对象编程是一种非常流行的**编程范式**（programming paradigm），所谓编程范式就是**程序设计的方法论**，简单的说就是程序员对程序的认知和理解以及他们编写代码的方式。 4 | 5 | 在前面的课程中，我们说过“**程序是指令的集合**”，运行程序时，程序中的语句会变成一条或多条指令，然后由CPU（中央处理器）去执行。为了简化程序的设计，我们又讲到了函数，**把相对独立且经常重复使用的代码放置到函数中**，在需要使用这些代码的时候调用函数即可。如果一个函数的功能过于复杂和臃肿，我们又可以进一步**将函数进一步拆分为多个子函数**来降低系统的复杂性。 6 | 7 | 不知大家是否发现，编程其实是写程序的人按照计算机的工作方式通过代码控制机器完成任务。但是，计算机的工作方式与人类正常的思维模式是不同的，如果编程就必须抛弃人类正常的思维方式去迎合计算机，编程的乐趣就少了很多。这里，我想说的并不是我们不能按照计算机的工作方式去编写代码，但是当我们需要开发一个复杂的系统时，这种方式会让代码过于复杂，从而导致开发和维护工作都变得举步维艰。 8 | 9 | 随着软件复杂性的增加，编写正确可靠的代码会变成了一项极为艰巨的任务，这也是很多人都坚信“软件开发是人类改造世界所有活动中最为复杂的活动”的原因。如何用程序描述复杂系统和解决复杂问题，就成为了所有程序员必须要思考和直面的问题。诞生于上世纪70年代的 Smalltalk 语言让软件开发者看到了希望，因为它引入了一种新的编程范式叫面向对象编程。在面向对象编程的世界里，程序中的**数据和操作数据的函数是一个逻辑上的整体**，我们称之为**对象**，**对象可以接收消息**，解决问题的方法就是**创建对象并向对象发出各种各样的消息**；通过消息传递，程序中的多个对象可以协同工作，这样就能构造出复杂的系统并解决现实中的问题。当然，面向对象编程的雏形还可以向前追溯到更早期的Simula语言，但这不是我们要讨论的重点。 10 | 11 | > **说明：** 今天我们使用的很多高级程序设计语言都支持面向对象编程，但是面向对象编程也不是解决软件开发中所有问题的“银弹”，或者说在软件开发这个行业目前还没有所谓的“银弹”。关于这个问题，大家可以参考 IBM360 系统之父弗雷德里克·布鲁克斯所发表的论文《没有银弹：软件工程的本质性与附属性工作》或软件工程的经典著作《人月神话》一书。 12 | 13 | ### 类和对象 14 | 15 | 如果要用一句话来概括面向对象编程，我认为下面的说法是相当精辟和准确的。 16 | 17 | > **面向对象编程**：把一组数据和处理数据的方法组成**对象**，把行为相同的对象归纳为**类**，通过**封装**隐藏对象的内部细节，通过**继承**实现类的特化和泛化，通过**多态**实现基于对象类型的动态分派。 18 | 19 | 这句话对初学者来说可能不那么容易理解，但是我可以先为大家圈出几个关键词：**对象**（object）、**类**（class）、**封装**（encapsulation）、**继承**（inheritance）、**多态**（polymorphism）。 20 | 21 | 我们先说说类和对象这两个词。在面向对象编程中，**类是一个抽象的概念，对象是一个具体的概念**。我们把同一类对象的共同特征抽取出来就是一个类，比如我们经常说的人类，这是一个抽象概念，而我们每个人就是人类的这个抽象概念下的实实在在的存在，也就是一个对象。简而言之，**类是对象的蓝图和模板，对象是类的实例，是可以接受消息的实体**。 22 | 23 | 在面向对象编程的世界中，**一切皆为对象**，**对象都有属性和行为**，**每个对象都是独一无二的**，而且**对象一定属于某个类**。对象的属性是对象的静态特征，对象的行为是对象的动态特征。按照上面的说法，如果我们把拥有共同特征的对象的属性和行为都抽取出来，就可以定义出一个类。 24 | 25 | 26 | 27 | ### 定义类 28 | 29 | 在 Python 语言中，我们可以使用`class`关键字加上类名来定义类，通过缩进我们可以确定类的代码块，就如同定义函数那样。在类的代码块中，我们需要写一些函数，我们说过类是一个抽象概念，那么这些函数就是我们对一类对象共同的动态特征的提取。写在类里面的函数我们通常称之为**方法**，方法就是对象的行为，也就是对象可以接收的消息。方法的第一个参数通常都是`self`，它代表了接收这个消息的对象本身。 30 | 31 | ```Python 32 | class Student: 33 | 34 | def study(self, course_name): 35 | print(f'学生正在学习{course_name}.') 36 | 37 | def play(self): 38 | print(f'学生正在玩游戏.') 39 | ``` 40 | 41 | ### 创建和使用对象 42 | 43 | 在我们定义好一个类之后，可以使用构造器语法来创建对象，代码如下所示。 44 | 45 | ```Python 46 | stu1 = Student() 47 | stu2 = Student() 48 | print(stu1) # <__main__.Student object at 0x10ad5ac50> 49 | print(stu2) # <__main__.Student object at 0x10ad5acd0> 50 | print(hex(id(stu1)), hex(id(stu2))) # 0x10ad5ac50 0x10ad5acd0 51 | ``` 52 | 53 | 在类的名字后跟上圆括号就是所谓的构造器语法，上面的代码创建了两个学生对象，一个赋值给变量`stu1`，一个赋值给变量`stu2`。当我们用`print`函数打印`stu1`和`stu2`两个变量时，我们会看到输出了对象在内存中的地址（十六进制形式），跟我们用`id`函数查看对象标识获得的值是相同的。现在我们可以告诉大家，我们定义的变量其实保存的是一个对象在内存中的逻辑地址（位置），通过这个逻辑地址，我们就可以在内存中找到这个对象。所以`stu3 = stu2`这样的赋值语句并没有创建新的对象，只是用一个新的变量保存了已有对象的地址。 54 | 55 | 接下来，我们尝试给对象发消息，即调用对象的方法。刚才的`Student`类中我们定义了`study`和`play`两个方法，两个方法的第一个参数`self`代表了接收消息的学生对象，`study`方法的第二个参数是学习的课程名称。Python中，给对象发消息有两种方式，请看下面的代码。 56 | 57 | ```Python 58 | # 通过“类.方法”调用方法 59 | # 第一个参数是接收消息的对象 60 | # 第二个参数是学习的课程名称 61 | Student.study(stu1, 'Python程序设计') # 学生正在学习Python程序设计. 62 | # 通过“对象.方法”调用方法 63 | # 点前面的对象就是接收消息的对象 64 | # 只需要传入第二个参数课程名称 65 | stu1.study('Python程序设计') # 学生正在学习Python程序设计. 66 | 67 | Student.play(stu2) # 学生正在玩游戏. 68 | stu2.play() # 学生正在玩游戏. 69 | ``` 70 | 71 | ### 初始化方法 72 | 73 | 大家可能已经注意到了，刚才我们创建的学生对象只有行为没有属性，如果要给学生对象定义属性，我们可以修改`Student`类，为其添加一个名为`__init__`的方法。在我们调用`Student`类的构造器创建对象时，首先会在内存中获得保存学生对象所需的内存空间，然后通过自动执行`__init__`方法，完成对内存的初始化操作，也就是把数据放到内存空间中。所以我们可以通过给`Student`类添加`__init__`方法的方式为学生对象指定属性，同时完成对属性赋初始值的操作，正因如此，`__init__`方法通常也被称为初始化方法。 74 | 75 | 我们对上面的`Student`类稍作修改，给学生对象添加`name`（姓名）和`age`（年龄）两个属性。 76 | 77 | ```Python 78 | class Student: 79 | """学生""" 80 | 81 | def __init__(self, name, age): 82 | """初始化方法""" 83 | self.name = name 84 | self.age = age 85 | 86 | def study(self, course_name): 87 | """学习""" 88 | print(f'{self.name}正在学习{course_name}.') 89 | 90 | def play(self): 91 | """玩耍""" 92 | print(f'{self.name}正在玩游戏.') 93 | ``` 94 | 95 | 修改刚才创建对象和给对象发消息的代码，重新执行一次，看看程序的执行结果有什么变化。 96 | 97 | ```Python 98 | # 调用Student类的构造器创建对象并传入初始化参数 99 | stu1 = Student('骆昊', 44) 100 | stu2 = Student('王大锤', 25) 101 | stu1.study('Python程序设计') # 骆昊正在学习Python程序设计. 102 | stu2.play() # 王大锤正在玩游戏. 103 | ``` 104 | 105 | 106 | ### 面向对象的支柱 107 | 108 | 面向对象编程有三大支柱，就是我们之前给大家划重点的时候圈出的三个词：**封装**、**继承**和**多态**。后面两个概念在下一节课中会详细说明，这里我们先说一下什么是封装。我自己对封装的理解是：**隐藏一切可以隐藏的实现细节，只向外界暴露简单的调用接口**。我们在类中定义的对象方法其实就是一种封装，这种封装可以让我们在创建对象之后，只需要给对象发送一个消息就可以执行方法中的代码，也就是说我们在只知道方法的名字和参数（方法的外部视图），不知道方法内部实现细节（方法的内部视图）的情况下就完成了对方法的使用。 109 | 110 | 举一个例子，假如要控制一个机器人帮我倒杯水，如果不使用面向对象编程，不做任何的封装，那么就需要向这个机器人发出一系列的指令，如站起来、向左转、向前走5步、拿起面前的水杯、向后转、向前走10步、弯腰、放下水杯、按下出水按钮、等待10秒、松开出水按钮、拿起水杯、向右转、向前走5步、放下水杯等，才能完成这个简单的操作，想想都觉得麻烦。按照面向对象编程的思想，我们可以将倒水的操作封装到机器人的一个方法中，当需要机器人帮我们倒水的时候，只需要向机器人对象发出倒水的消息就可以了，这样做不是更好吗？ 111 | 112 | 在很多场景下，面向对象编程其实就是一个三步走的问题。第一步定义类，第二步创建对象，第三步给对象发消息。当然，有的时候我们是不需要第一步的，因为我们想用的类可能已经存在了。之前我们说过，Python内置的`list`、`set`、`dict`其实都是类，如果要创建列表、集合、字典对象，我们就不用自定义类了。当然，有的类并不是 Python 标准库中直接提供的，它可能来自于第三方的代码，如何安装和使用三方代码在后续课程中会进行讨论。在某些特殊的场景中，我们会用到名为“内置对象”的对象，所谓“内置对象”就是说上面三步走的第一步和第二步都不需要了，因为类已经存在而且对象已然创建过了，直接向对象发消息就可以了，这也就是我们常说的“开箱即用”。 113 | 114 | ### 面向对象案例 115 | 116 | #### 案例1：定义一个类描述数字时钟。 117 | 118 | ```Python 119 | import time 120 | 121 | 122 | # 定义时钟类 123 | class Clock: 124 | """数字时钟""" 125 | 126 | def __init__(self, hour=0, minute=0, second=0): 127 | """初始化方法 128 | :param hour: 时 129 | :param minute: 分 130 | :param second: 秒 131 | """ 132 | self.hour = hour 133 | self.min = minute 134 | self.sec = second 135 | 136 | def run(self): 137 | """走字""" 138 | self.sec += 1 139 | if self.sec == 60: 140 | self.sec = 0 141 | self.min += 1 142 | if self.min == 60: 143 | self.min = 0 144 | self.hour += 1 145 | if self.hour == 24: 146 | self.hour = 0 147 | 148 | def show(self): 149 | """显示时间""" 150 | return f'{self.hour:0>2d}:{self.min:0>2d}:{self.sec:0>2d}' 151 | 152 | 153 | # 创建时钟对象 154 | clock = Clock(23, 59, 58) 155 | while True: 156 | # 给时钟对象发消息读取时间 157 | print(clock.show()) 158 | # 休眠1秒钟 159 | time.sleep(1) 160 | # 给时钟对象发消息使其走字 161 | clock.run() 162 | ``` 163 | 164 | #### 案例2：定义一个类描述平面上的点，要求提供计算到另一个点距离的方法。 165 | 166 | ```Python 167 | class Point: 168 | """平面上的点""" 169 | 170 | def __init__(self, x=0, y=0): 171 | """初始化方法 172 | :param x: 横坐标 173 | :param y: 纵坐标 174 | """ 175 | self.x, self.y = x, y 176 | 177 | def distance_to(self, other): 178 | """计算与另一个点的距离 179 | :param other: 另一个点 180 | """ 181 | dx = self.x - other.x 182 | dy = self.y - other.y 183 | return (dx * dx + dy * dy) ** 0.5 184 | 185 | def __str__(self): 186 | return f'({self.x}, {self.y})' 187 | 188 | 189 | p1 = Point(3, 5) 190 | p2 = Point(6, 9) 191 | print(p1) # 调用对象的__str__魔法方法 192 | print(p2) 193 | print(p1.distance_to(p2)) 194 | ``` 195 | 196 | ### 总结 197 | 198 | 面向对象编程是一种非常流行的编程范式，除此之外还有**指令式编程**、**函数式编程**等编程范式。由于现实世界是由对象构成的，而对象是可以接收消息的实体，所以**面向对象编程更符合人类正常的思维习惯**。类是抽象的，对象是具体的，有了类就能创建对象，有了对象就可以接收消息，这就是面向对象编程的基础。定义类的过程是一个抽象的过程，找到对象公共的属性属于数据抽象，找到对象公共的方法属于行为抽象。抽象的过程是一个仁者见仁智者见智的过程，对同一类对象进行抽象可能会得到不同的结果，如下图所示。 199 | 200 | 201 | 202 | > **说明：** 本节课的插图来自于 Grady Booc 等撰写的《面向对象分析与设计》一书，该书是讲解面向对象编程的经典著作，有兴趣的读者可以购买和阅读这本书来了解更多的面向对象的相关知识。 203 | 204 | -------------------------------------------------------------------------------- /第19课：面向对象编程进阶.md: -------------------------------------------------------------------------------- 1 | ## 第19课：面向对象编程进阶 2 | 3 | 前面我们讲解了 Python 面向对象编程的一些基础知识，本节我们继续讨论面向对象编程相关的内容。 4 | 5 | ### 可见性和属性装饰器 6 | 7 | 在很多面向对象编程语言中，对象的属性通常会被设置为私有（private）或受保护（protected）的成员，简单的说就是不允许直接访问这些属性；对象的方法通常都是公开的（public），因为公开的方法是对象能够接受的消息，也是对象暴露给外界的调用接口，这就是所谓的访问可见性。在 Python 中，可以通过给对象属性名添加前缀下划线的方式来说明属性的访问可见性，例如，可以用`__name`表示一个私有属性，`_name`表示一个受保护属性，代码如下所示。 8 | 9 | ```Python 10 | class Student: 11 | 12 | def __init__(self, name, age): 13 | self.__name = name 14 | self.__age = age 15 | 16 | def study(self, course_name): 17 | print(f'{self.__name}正在学习{course_name}.') 18 | 19 | 20 | stu = Student('王大锤', 20) 21 | stu.study('Python程序设计') 22 | print(stu.__name) # AttributeError: 'Student' object has no attribute '__name' 23 | ``` 24 | 25 | 上面代码的最后一行会引发`AttributeError`（属性错误）异常，异常消息为：`'Student' object has no attribute '__name'`。由此可见，以`__`开头的属性`__name`相当于是私有的，在类的外面无法直接访问，但是类里面的`study`方法中可以通过`self.__name`访问该属性。需要说明的是，大多数使用 Python 语言的人在定义类时，通常不会选择让对象的属性私有或受保护，正如有一句名言说的：“**We are all consenting adults here**”（大家都是成年人），成年人可以为自己的行为负责，而不需要通过 Python 语言本身来限制访问可见性。事实上，大多数的程序员都认为**开放比封闭要好**，把对象的属性私有化并非必不可少的东西，所以 Python 语言并没有从语义上做出最严格的限定，也就是说上面的代码如果你愿意，用`stu._Student__name`的方式仍然可以访问到私有属性`__name`，有兴趣的读者可以自己试一试。 26 | 27 | ### 动态属性 28 | 29 | Python 语言属于动态语言，维基百科对动态语言的解释是：“在运行时可以改变其结构的语言，例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化”。动态语言非常灵活，目前流行的 Python 和 JavaScript 都是动态语言，除此之外，诸如 PHP、Ruby 等也都属于动态语言，而 C、C++ 等语言则不属于动态语言。 30 | 31 | 在 Python 中，我们可以动态为对象添加属性，这是 Python 作为动态类型语言的一项特权，代码如下所示。需要提醒大家的是，对象的方法其实本质上也是对象的属性，如果给对象发送一个无法接收的消息，引发的异常仍然是`AttributeError`。 32 | 33 | ```Python 34 | class Student: 35 | 36 | def __init__(self, name, age): 37 | self.name = name 38 | self.age = age 39 | 40 | 41 | stu = Student('王大锤', 20) 42 | stu.sex = '男' # 给学生对象动态添加sex属性 43 | ``` 44 | 45 | 如果不希望在使用对象时动态的为对象添加属性，可以使用 Python 语言中的`__slots__`魔法。对于`Student`类来说，可以在类中指定`__slots__ = ('name', 'age')`，这样`Student`类的对象只能有`name`和`age`属性，如果想动态添加其他属性将会引发异常，代码如下所示。 46 | 47 | ```Python 48 | class Student: 49 | __slots__ = ('name', 'age') 50 | 51 | def __init__(self, name, age): 52 | self.name = name 53 | self.age = age 54 | 55 | 56 | stu = Student('王大锤', 20) 57 | # AttributeError: 'Student' object has no attribute 'sex' 58 | stu.sex = '男' 59 | ``` 60 | 61 | ### 静态方法和类方法 62 | 63 | 之前我们在类中定义的方法都是对象方法，换句话说这些方法都是对象可以接收的消息。除了对象方法之外，类中还可以有静态方法和类方法，这两类方法是发给类的消息，二者并没有实质性的区别。在面向对象的世界里，一切皆为对象，我们定义的每一个类其实也是一个对象，而静态方法和类方法就是发送给类对象的消息。那么，什么样的消息会直接发送给类对象呢？ 64 | 65 | 举一个例子，定义一个三角形类，通过传入三条边的长度来构造三角形，并提供计算周长和面积的方法。计算周长和面积肯定是三角形对象的方法，这一点毫无疑问。但是在创建三角形对象时，传入的三条边长未必能构造出三角形，为此我们可以先写一个方法来验证给定的三条边长是否可以构成三角形，这种方法很显然就不是对象方法，因为在调用这个方法时三角形对象还没有创建出来。我们可以把这类方法设计为静态方法或类方法，也就是说这类方法不是发送给三角形对象的消息，而是发送给三角形类的消息，代码如下所示。 66 | 67 | ```Python 68 | class Triangle(object): 69 | """三角形""" 70 | 71 | def __init__(self, a, b, c): 72 | """初始化方法""" 73 | self.a = a 74 | self.b = b 75 | self.c = c 76 | 77 | @staticmethod 78 | def is_valid(a, b, c): 79 | """判断三条边长能否构成三角形(静态方法)""" 80 | return a + b > c and b + c > a and a + c > b 81 | 82 | # @classmethod 83 | # def is_valid(cls, a, b, c): 84 | # """判断三条边长能否构成三角形(类方法)""" 85 | # return a + b > c and b + c > a and a + c > b 86 | 87 | def perimeter(self): 88 | """计算周长""" 89 | return self.a + self.b + self.c 90 | 91 | def area(self): 92 | """计算面积""" 93 | p = self.perimeter() / 2 94 | return (p * (p - self.a) * (p - self.b) * (p - self.c)) ** 0.5 95 | ``` 96 | 97 | 上面的代码使用`staticmethod`装饰器声明了`is_valid`方法是`Triangle`类的静态方法，如果要声明类方法，可以使用`classmethod`装饰器（如上面的代码15~18行所示）。可以直接使用`类名.方法名`的方式来调用静态方法和类方法，二者的区别在于，类方法的第一个参数是类对象本身，而静态方法则没有这个参数。简单的总结一下，**对象方法、类方法、静态方法都可以通过“类名.方法名”的方式来调用，区别在于方法的第一个参数到底是普通对象还是类对象，还是没有接受消息的对象**。静态方法通常也可以直接写成一个独立的函数，因为它并没有跟特定的对象绑定。 98 | 99 | 这里做一个补充说明，我们可以给上面计算三角形周长和面积的方法添加一个`property`装饰器（Python 内置类型），这样三角形类的`perimeter`和`area`就变成了两个属性，不再通过调用方法的方式来访问，而是用对象访问属性的方式直接获得，修改后的代码如下所示。 100 | 101 | ```python 102 | class Triangle(object): 103 | """三角形""" 104 | 105 | def __init__(self, a, b, c): 106 | """初始化方法""" 107 | self.a = a 108 | self.b = b 109 | self.c = c 110 | 111 | @staticmethod 112 | def is_valid(a, b, c): 113 | """判断三条边长能否构成三角形(静态方法)""" 114 | return a + b > c and b + c > a and a + c > b 115 | 116 | @property 117 | def perimeter(self): 118 | """计算周长""" 119 | return self.a + self.b + self.c 120 | 121 | @property 122 | def area(self): 123 | """计算面积""" 124 | p = self.perimeter / 2 125 | return (p * (p - self.a) * (p - self.b) * (p - self.c)) ** 0.5 126 | 127 | 128 | t = Triangle(3, 4, 5) 129 | print(f'周长: {t.perimeter}') 130 | print(f'面积: {t.area}') 131 | ``` 132 | 133 | ### 继承和多态 134 | 135 | 面向对象的编程语言支持在已有类的基础上创建新类，从而减少重复代码的编写。提供继承信息的类叫做父类（超类、基类），得到继承信息的类叫做子类（派生类、衍生类）。例如，我们定义一个学生类和一个老师类，我们会发现他们有大量的重复代码，而这些重复代码都是老师和学生作为人的公共属性和行为，所以在这种情况下，我们应该先定义人类，再通过继承，从人类派生出老师类和学生类，代码如下所示。 136 | 137 | ```Python 138 | class Person: 139 | """人""" 140 | 141 | def __init__(self, name, age): 142 | self.name = name 143 | self.age = age 144 | 145 | def eat(self): 146 | print(f'{self.name}正在吃饭.') 147 | 148 | def sleep(self): 149 | print(f'{self.name}正在睡觉.') 150 | 151 | 152 | class Student(Person): 153 | """学生""" 154 | 155 | def __init__(self, name, age): 156 | super().__init__(name, age) 157 | 158 | def study(self, course_name): 159 | print(f'{self.name}正在学习{course_name}.') 160 | 161 | 162 | class Teacher(Person): 163 | """老师""" 164 | 165 | def __init__(self, name, age, title): 166 | super().__init__(name, age) 167 | self.title = title 168 | 169 | def teach(self, course_name): 170 | print(f'{self.name}{self.title}正在讲授{course_name}.') 171 | 172 | 173 | 174 | stu1 = Student('白元芳', 21) 175 | stu2 = Student('狄仁杰', 22) 176 | tea1 = Teacher('武则天', 35, '副教授') 177 | stu1.eat() 178 | stu2.sleep() 179 | tea1.eat() 180 | stu1.study('Python程序设计') 181 | tea1.teach('Python程序设计') 182 | stu2.study('数据科学导论') 183 | ``` 184 | 185 | 继承的语法是在定义类的时候，在类名后的圆括号中指定当前类的父类。如果定义一个类的时候没有指定它的父类是谁，那么默认的父类是`object`类。`object`类是 Python 中的顶级类，这也就意味着所有的类都是它的子类，要么直接继承它，要么间接继承它。Python 语言允许多重继承，也就是说一个类可以有一个或多个父类，关于多重继承的问题我们在后面会有更为详细的讨论。在子类的初始化方法中，我们可以通过`super().__init__()`来调用父类初始化方法，`super`函数是 Python 内置函数中专门为获取当前对象的父类对象而设计的。从上面的代码可以看出，子类除了可以通过继承得到父类提供的属性和方法外，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力。在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为，也叫做“里氏替换原则”（Liskov Substitution Principle）。 186 | 187 | 子类继承父类的方法后，还可以对方法进行重写（重新实现该方法），不同的子类可以对父类的同一个方法给出不同的实现版本，这样的方法在程序运行时就会表现出多态行为（调用相同的方法，做了不同的事情）。多态是面向对象编程中最精髓的部分，当然也是对初学者来说最难以理解和灵活运用的部分，我们会在下一个章节用专门的例子来讲解这个知识点。 188 | 189 | ### 总结 190 | 191 | Python 是动态类型语言，Python 中的对象可以动态的添加属性，对象的方法其实也是属性，只不过和该属性对应的是一个可以调用的函数。在面向对象的世界中，**一切皆为对象**，我们定义的类也是对象，所以**类也可以接收消息**，对应的方法是类方法或静态方法。通过继承，我们**可以从已有的类创建新类**，实现对已有类代码的复用。 192 | -------------------------------------------------------------------------------- /第20课：面向对象编程应用.md: -------------------------------------------------------------------------------- 1 | ## 第20课：面向对象编程应用 2 | 3 | 面向对象编程对初学者来说不难理解但很难应用，虽然我们为大家总结过面向对象的三步走方法（定义类、创建对象、给对象发消息），但是说起来容易做起来难。**大量的编程练习**和**阅读优质的代码**可能是这个阶段最能够帮助到大家的两件事情。接下来我们还是通过经典的案例来剖析面向对象编程的知识，同时也通过这些案例把我们之前学过的 Python 知识都串联起来。 4 | 5 | ### 经典案例 6 | 7 | #### 案例1：扑克游戏。 8 | 9 | > **说明**：简单起见，我们的扑克只有52张牌（没有大小王），游戏需要将52张牌发到4个玩家的手上，每个玩家手上有13张牌，按照黑桃、红心、草花、方块的顺序和点数从小到大排列，暂时不实现其他的功能。 10 | 11 | 使用面向对象编程方法，首先需要从问题的需求中找到对象并抽象出对应的类，此外还要找到对象的属性和行为。当然，这件事情并不是特别困难，我们可以从需求的描述中找出名词和动词，名词通常就是对象或者是对象的属性，而动词通常是对象的行为。扑克游戏中至少应该有三类对象，分别是牌、扑克和玩家，牌、扑克、玩家三个类也并不是孤立的。类和类之间的关系可以粗略的分为**is-a关系（继承）**、**has-a关系（关联）**和**use-a关系（依赖）**。很显然扑克和牌是has-a关系，因为一副扑克有（has-a）52张牌；玩家和牌之间不仅有关联关系还有依赖关系，因为玩家手上有（has-a）牌而且玩家使用了（use-a）牌。 12 | 13 | 牌的属性显而易见，有花色和点数。我们可以用0到3的四个数字来代表四种不同的花色，但是这样的代码可读性会非常糟糕，因为我们并不知道黑桃、红心、草花、方块跟0到3的数字的对应关系。如果一个变量的取值只有有限多个选项，我们可以使用枚举。与 C、Java 等语言不同的是，Python 中没有声明枚举类型的关键字，但是可以通过继承`enum`模块的`Enum`类来创建枚举类型，代码如下所示。 14 | 15 | ```Python 16 | from enum import Enum 17 | 18 | 19 | class Suite(Enum): 20 | """花色(枚举)""" 21 | SPADE, HEART, CLUB, DIAMOND = range(4) 22 | ``` 23 | 24 | 通过上面的代码可以看出，定义枚举类型其实就是定义符号常量，如`SPADE`、`HEART`等。每个符号常量都有与之对应的值，这样表示黑桃就可以不用数字`0`，而是用`Suite.SPADE`；同理，表示方块可以不用数字`3`， 而是用`Suite.DIAMOND`。注意，使用符号常量肯定是优于使用字面常量的，因为能够读懂英文就能理解符号常量的含义，代码的可读性会提升很多。Python 中的枚举类型是可迭代类型，简单的说就是可以将枚举类型放到`for-in`循环中，依次取出每一个符号常量及其对应的值，如下所示。 25 | 26 | ```Python 27 | for suite in Suite: 28 | print(f'{suite}: {suite.value}') 29 | ``` 30 | 31 | 接下来我们可以定义牌类。 32 | 33 | ```Python 34 | class Card: 35 | """牌""" 36 | 37 | def __init__(self, suite, face): 38 | self.suite = suite 39 | self.face = face 40 | 41 | def __repr__(self): 42 | suites = '♠♥♣♦' 43 | faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'] 44 | return f'{suites[self.suite.value]}{faces[self.face]}' # 返回牌的花色和点数 45 | ``` 46 | 47 | 可以通过下面的代码来测试下`Card`类。 48 | 49 | ```Python 50 | card1 = Card(Suite.SPADE, 5) 51 | card2 = Card(Suite.HEART, 13) 52 | print(card1) # ♠5 53 | print(card2) # ♥K 54 | ``` 55 | 56 | 接下来我们定义扑克类。 57 | 58 | ```Python 59 | import random 60 | 61 | 62 | class Poker: 63 | """扑克""" 64 | 65 | def __init__(self): 66 | self.cards = [Card(suite, face) 67 | for suite in Suite 68 | for face in range(1, 14)] # 52张牌构成的列表 69 | self.current = 0 # 记录发牌位置的属性 70 | 71 | def shuffle(self): 72 | """洗牌""" 73 | self.current = 0 74 | random.shuffle(self.cards) # 通过random模块的shuffle函数实现随机乱序 75 | 76 | def deal(self): 77 | """发牌""" 78 | card = self.cards[self.current] 79 | self.current += 1 80 | return card 81 | 82 | @property 83 | def has_next(self): 84 | """还有没有牌可以发""" 85 | return self.current < len(self.cards) 86 | ``` 87 | 88 | 可以通过下面的代码来测试下`Poker`类。 89 | 90 | ```Python 91 | poker = Poker() 92 | print(poker.cards) # 洗牌前的牌 93 | poker.shuffle() 94 | print(poker.cards) # 洗牌后的牌 95 | ``` 96 | 97 | 定义玩家类。 98 | 99 | ```Python 100 | class Player: 101 | """玩家""" 102 | 103 | def __init__(self, name): 104 | self.name = name 105 | self.cards = [] # 玩家手上的牌 106 | 107 | def get_one(self, card): 108 | """摸牌""" 109 | self.cards.append(card) 110 | 111 | def arrange(self): 112 | """整理手上的牌""" 113 | self.cards.sort() 114 | ``` 115 | 116 | 创建四个玩家并将牌发到玩家的手上。 117 | 118 | ```Python 119 | poker = Poker() 120 | poker.shuffle() 121 | players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')] 122 | # 将牌轮流发到每个玩家手上每人13张牌 123 | for _ in range(13): 124 | for player in players: 125 | player.get_one(poker.deal()) 126 | # 玩家整理手上的牌输出名字和手牌 127 | for player in players: 128 | player.arrange() 129 | print(f'{player.name}: ', end='') 130 | print(player.cards) 131 | ``` 132 | 133 | 执行上面的代码会在`player.arrange()`那里出现异常，因为`Player`的`arrange`方法使用了列表的`sort`对玩家手上的牌进行排序，排序需要比较两个`Card`对象的大小，而`<`运算符又不能直接作用于`Card`类型，所以就出现了`TypeError`异常，异常消息为：`'<' not supported between instances of 'Card' and 'Card'`。 134 | 135 | 为了解决这个问题，我们可以对`Card`类的代码稍作修改，使得两个`Card`对象可以直接用`<`进行大小的比较。这里用到技术叫**运算符重载**，Python 中要实现对`<`运算符的重载，需要在类中添加一个名为`__lt__`的魔术方法。很显然，魔术方法`__lt__`中的`lt`是英文单词“less than”的缩写，以此类推，魔术方法`__gt__`对应`>`运算符，魔术方法`__le__`对应`<=`运算符，`__ge__`对应`>=`运算符，`__eq__`对应`==`运算符，`__ne__`对应`!=`运算符。 136 | 137 | 修改后的`Card`类代码如下所示。 138 | 139 | ```Python 140 | class Card: 141 | """牌""" 142 | 143 | def __init__(self, suite, face): 144 | self.suite = suite 145 | self.face = face 146 | 147 | def __repr__(self): 148 | suites = '♠♥♣♦' 149 | faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'] 150 | return f'{suites[self.suite.value]}{faces[self.face]}' 151 | 152 | def __lt__(self, other): 153 | if self.suite == other.suite: 154 | return self.face < other.face # 花色相同比较点数的大小 155 | return self.suite.value < other.suite.value # 花色不同比较花色对应的值 156 | ``` 157 | 158 | >**说明：** 大家可以尝试在上面代码的基础上写一个简单的扑克游戏，如21点游戏（Black Jack），游戏的规则可以自己在网上找一找。 159 | 160 | #### 案例2：工资结算系统。 161 | 162 | > **要求**：某公司有三种类型的员工，分别是部门经理、程序员和销售员。需要设计一个工资结算系统，根据提供的员工信息来计算员工的月薪。其中，部门经理的月薪是固定15000元；程序员按工作时间（以小时为单位）支付月薪，每小时200元；销售员的月薪由1800元底薪加上销售额5%的提成两部分构成。 163 | 164 | 通过对上述需求的分析，可以看出部门经理、程序员、销售员都是员工，有相同的属性和行为，那么我们可以先设计一个名为`Employee`的父类，再通过继承的方式从这个父类派生出部门经理、程序员和销售员三个子类。很显然，后续的代码不会创建`Employee` 类的对象，因为我们需要的是具体的员工对象，所以这个类可以设计成专门用于继承的抽象类。Python 语言中没有定义抽象类的关键字，但是可以通过`abc`模块中名为`ABCMeta` 的元类来定义抽象类。关于元类的概念此处不展开讲解，当然大家不用纠结，照做即可。 165 | 166 | ```Python 167 | from abc import ABCMeta, abstractmethod 168 | 169 | 170 | class Employee(metaclass=ABCMeta): 171 | """员工""" 172 | 173 | def __init__(self, name): 174 | self.name = name 175 | 176 | @abstractmethod 177 | def get_salary(self): 178 | """结算月薪""" 179 | pass 180 | ``` 181 | 182 | 在上面的员工类中，有一个名为`get_salary`的方法用于结算月薪，但是由于还没有确定是哪一类员工，所以结算月薪虽然是员工的公共行为但这里却没有办法实现。对于暂时无法实现的方法，我们可以使用`abstractmethod`装饰器将其声明为抽象方法，所谓**抽象方法就是只有声明没有实现的方法**，**声明这个方法是为了让子类去重写这个方法**。接下来的代码展示了如何从员工类派生出部门经理、程序员、销售员这三个子类以及子类如何重写父类的抽象方法。 183 | 184 | ```Python 185 | class Manager(Employee): 186 | """部门经理""" 187 | 188 | def get_salary(self): 189 | return 15000.0 190 | 191 | 192 | class Programmer(Employee): 193 | """程序员""" 194 | 195 | def __init__(self, name, working_hour=0): 196 | super().__init__(name) 197 | self.working_hour = working_hour 198 | 199 | def get_salary(self): 200 | return 200 * self.working_hour 201 | 202 | 203 | class Salesman(Employee): 204 | """销售员""" 205 | 206 | def __init__(self, name, sales=0): 207 | super().__init__(name) 208 | self.sales = sales 209 | 210 | def get_salary(self): 211 | return 1800 + self.sales * 0.05 212 | ``` 213 | 214 | 上面的`Manager`、`Programmer`、`Salesman`三个类都继承自`Employee`，三个类都分别重写了`get_salary`方法。**重写就是子类对父类已有的方法重新做出实现**。相信大家已经注意到了，三个子类中的`get_salary`各不相同，所以这个方法在程序运行时会产生**多态行为**，多态简单的说就是**调用相同的方法**，**不同的子类对象做不同的事情**。 215 | 216 | 我们通过下面的代码来完成这个工资结算系统，由于程序员和销售员需要分别录入本月的工作时间和销售额，所以在下面的代码中我们使用了 Python 内置的`isinstance`函数来判断员工对象的类型。我们之前讲过的`type`函数也能识别对象的类型，但是`isinstance`函数更加强大，因为它可以判断出一个对象是不是某个继承结构下的子类型，你可以简单的理解为`type`函数是对对象类型的精准匹配，而`isinstance`函数是对对象类型的模糊匹配。 217 | 218 | ```Python 219 | emps = [Manager('刘备'), Programmer('诸葛亮'), Manager('曹操'), Programmer('荀彧'), Salesman('张辽')] 220 | for emp in emps: 221 | if isinstance(emp, Programmer): 222 | emp.working_hour = int(input(f'请输入{emp.name}本月工作时间: ')) 223 | elif isinstance(emp, Salesman): 224 | emp.sales = float(input(f'请输入{emp.name}本月销售额: ')) 225 | print(f'{emp.name}本月工资为: ￥{emp.get_salary():.2f}元') 226 | ``` 227 | 228 | ### 总结 229 | 230 | 面向对象的编程思想非常的好，也符合人类的正常思维习惯，但是要想灵活运用面向对象编程中的抽象、封装、继承、多态需要长时间的积累和沉淀，这件事情无法一蹴而就，因为知识的积累本就是涓滴成河的过程。 231 | --------------------------------------------------------------------------------