文章目录
PyCharm 的初始设置（知道）
目标
- 恢复 PyCharm 的初始设置
- 第一次启动 PyCharm
- 新建一个 Python 项目
- 设置 PyCharm 的字体显示
- PyCharm 的升级以及其他
PyCharm 的官方网站地址是：https://www.jetbrains.com/pycharm/
01. 恢复 PyCharm 的初始设置
PyCharm 的 配置信息 是保存在 用户家目录下 的 .PyCharmxxxx.x 目录下的，xxxx.x 表示当前使用的 PyCharm 的版本号
如果要恢复 PyCharm 的初始设置，可以按照以下步骤进行：
-
- 关闭正在运行的
PyCharm
- 关闭正在运行的
-
- 在终端中执行以下终端命令，删除
PyCharm的配置信息目录：
- 在终端中执行以下终端命令，删除
$ rm -r ~/.PyCharm2016.3
-
- 重新启动
PyCharm
- 重新启动
02. 第一次启动 PyCharm
- 导入配置信息
- 选择许可协议
- 配置初始界面
2.1 导入配置信息
- 在第一次启动
PyCharm时，会首先提示用户是否导入 之前的配置信息 - 如果是第一次使用，直接点击 OK 按钮
2.2 选择许可协议
- PyCharm 是一个付费软件，购买费用为 199$ / 年 或者 19.90$ ／ 月
- 不过 PyCharm 提供了对 学生和教师免费使用的版本
- 下载地址是：https://www.jetbrains.com/pycharm-edu/download/#section=linux
- 商业版本会提示输入注册信息，或者选择免费评估
2.3 PyCharm 的配置初始界面
- 在初始配置界面，可以通过
Editor colors and fonts选择 编辑器的配色方案
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6KVxrITK-1630805410382)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day01_markdown/markdown/media/14950463298537/003_PyCharm初始配置界面.png)]
2.4 欢迎界面
- 所有基础配置工作结束之后，就可以看到
PyCharm的 欢迎界面了，通过 欢迎界面 就可以开始开发 Python 项目了
03. 新建/打开一个 Python 项目
3.1 项目简介
- 开发 项目 就是开发一个 专门解决一个复杂业务功能的软件
- 通常每 一个项目 就具有一个 独立专属的目录，用于保存 所有和项目相关的文件
- 一个项目通常会包含 很多源文件
3.2 打开 Python 项目
- 直接点击 Open 按钮，然后浏览到之前保存 Python 文件的目录，既可以打开项目
- 打开之后，会在目录下新建一个
.idea的目录，用于保存 项目相关的信息，例如：解释器版本、项目包含的文件等等 - 第一次打开项目，需要耐心等待
PyCharm对项目进行初始设置
设置项目使用的解释器版本
- 打开的目录如果不是由
PyCharm建立的项目目录，有的时候 使用的解释器版本是Python 2.x的，需要单独设置解释器的版本 - 通过 File / Settings… 可以打开设置窗口，如下图所示：
3.3 新建项目
1) 命名规则
-
以后 项目名 前面都以 数字编号，随着知识点递增，编号递增
- 例如：01_Python 基础、02_分支、03_循环…
-
每个项目下的 文件名 都以
hm_xx_知识点方式来命名- 其中 xx 是演练文件的序号
-
注意
-
- 命名文件名时建议只使用 小写字母、数字 和 下划线
-
- 文件名不能以数字开始
-
-
通过 欢迎界面 或者菜单 File / New Project 可以新建项目
2) 演练步骤
- 新建
01_Python基础项目，使用 Python 3.x 解释器 - 在项目下新建
hm_01_hello.pyPython 文件 - 编写
print("Hello Python")代码
04. 设置 PyCharm 的字体显示
05. PyCharm 的升级以及其他
PyCharm 提供了对 学生和教师免费使用的版本
- 教育版下载地址：https://www.jetbrains.com/pycharm-edu/download/#section=linux
- 专业版下载地址：https://www.jetbrains.com/pycharm/download/#section=linux
5.1 安装和启动步骤
-
- 执行以下终端命令，解压缩下载后的安装包
$ tar -zxvf pycharm-professional-2017.1.3.tar.gz
-
- 将解压缩后的目录移动到
/opt目录下，可以方便其他用户使用
- 将解压缩后的目录移动到
/opt目录用户存放给主机额外安装的软件
$ sudo mv pycharm-2017.1.3/ /opt/
-
- 切换工作目录
$ cd /opt/pycharm-2017.1.3/bin
-
- 启动
PyCharm
- 启动
$ ./pycharm.sh
5.2 设置专业版启动图标
- 在专业版中，选择菜单 Tools / Create Desktop Entry… 可以设置任务栏启动图标
- 注意：设置图标时，需要勾选
Create the entry for all users
- 注意：设置图标时，需要勾选
5.3 卸载之前版本的 PyCharm
1) 程序安装
-
- 程序文件目录
- 将安装包解压缩，并且移动到
/opt目录下 - 所有的相关文件都保存在解压缩的目录中
-
- 配置文件目录
- 启动
PyCharm后，会在用户家目录下建立一个.PyCharmxxx的隐藏目录 - 保存
PyCharm相关的配置信息
-
- 快捷方式文件
/usr/share/applications/jetbrains-pycharm.desktop
在
ubuntu中，应用程序启动的快捷方式通常都保存在/usr/share/applications目录下
2) 程序卸载
-
要卸载
PyCharm只需要做以下两步工作： -
- 删除解压缩目录
$ sudo rm -r /opt/pycharm-2016.3.1/
-
- 删除家目录下用于保存配置信息的隐藏目录
$ rm -r ~/.PyCharm2016.3/
如果不再使用 PyCharm 还需要将
/usr/share/applications/下的jetbrains-pycharm.desktop删掉
5.4 教育版安装演练
# 1. 解压缩下载后的安装包
$ tar -zxvf pycharm-edu-3.5.1.tar.gz
# 2. 将解压缩后的目录移动到 `/opt` 目录下，可以方便其他用户使用
$ sudo mv pycharm-edu-3.5.1/ /opt/
# 3. 启动 `PyCharm`
/opt/pycharm-edu-3.5.1/bin/pycharm.sh
后续课程都使用专业版本演练
设置启动图标
-
- 编辑快捷方式文件
$ sudo gedit /usr/share/applications/jetbrains-pycharm.desktop
-
- 按照以下内容修改文件内容，需要注意指定正确的
pycharm目录
- 按照以下内容修改文件内容，需要注意指定正确的
[Desktop Entry]
Version=1.0
Type=Application
Name=PyCharm
Icon=/opt/pycharm-edu-3.5.1/bin/pycharm.png
Exec="/opt/pycharm-edu-3.5.1/bin/pycharm.sh" %f
Comment=The Drive to Develop
Categories=Development;IDE;
Terminal=false
StartupWMClass=jetbrains-pycharm
第一个 Python 程序
目标
- 第一个
HelloPython程序 Python 2.x与3.x版本简介- 执行
Python程序的三种方式- 解释器 ——
python/python3 - 交互式 ——
ipython - 集成开发环境 ——
PyCharm
- 解释器 ——
01. 第一个 HelloPython 程序
1.1 Python 源程序的基本概念
- Python 源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做
Python的开发 - Python 程序的 文件扩展名 通常都是
.py
1.2 演练步骤
- 在桌面下，新建
认识Python目录 - 在
认识Python目录下新建01-HelloPython.py文件 - 使用 gedit 编辑
01-HelloPython.py并且输入以下内容：
print("hello python")print("hello world")
- 在终端中输入以下命令执行
01-HelloPython.py
$ python 01-HelloPython.py
python中我们学习的第一个 函数
1.3 演练扩展 —— 认识错误（BUG）
关于错误
- 编写的程序不能正常执行，或者执行的结果不是我们期望的
- 俗称
BUG，是程序员在开发时非常常见的，初学者常见错误的原因包括：- 手误
- 对已经学习过的知识理解还存在不足
- 对语言还有需要学习和提升的内容
- 在学习语言时，不仅要学会语言的语法，而且还要学会如何认识错误和解决错误的方法
每一个程序员都是在不断地修改错误中成长的
第一个演练中的常见错误
- 1> 手误，例如使用
pirnt("Hello world")
NameError: name 'pirnt' is not defined
名称错误：'pirnt' 名字没有定义
- 2> 将多条
print写在一行
SyntaxError: invalid syntax
语法错误：语法无效
每行代码负责完成一个动作
- 3> 缩进错误
IndentationError: unexpected indent
缩进错误：不期望出现的缩进
- Python 是一个格式非常严格的程序设计语言
- 目前而言，大家记住每行代码前面都不要增加空格
- 4> python 2.x 默认不支持中文
目前市场上有两个 Python 的版本并存着，分别是 Python 2.x 和 Python 3.x
- Python 2.x 默认不支持中文，具体原因，等到介绍 字符编码 时给大家讲解
- Python 2.x 的解释器名称是 python
- Python 3.x 的解释器名称是 python3
SyntaxError: Non-ASCII character '\xe4' in file 01-HelloPython.py on line 3, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details语法错误： 在 01-HelloPython.py 中第 3 行出现了非 ASCII 字符 '\xe4'，但是没有声明文件编码请访问 http://python.org/dev/peps/pep-0263/ 了解详细信息
ASCII字符只包含256个字符，不支持中文- 有关字符编码的问题，后续会讲
单词列表
* error 错误
* name 名字
* defined 已经定义
* syntax 语法
* invalid 无效
* Indentation 索引
* unexpected 意外的，不期望的
* character 字符
* line 行
* encoding 编码
* declared 声明
* details 细节，详细信息
* ASCII 一种字符编码
02. Python 2.x 与 3.x 版本简介
目前市场上有两个 Python 的版本并存着，分别是 Python 2.x 和 Python 3.x
新的 Python 程序建议使用
Python 3.0版本的语法
- Python 2.x 是 过去的版本
- 解释器名称是 python
- Python 3.x 是 现在和未来 主流的版本
- 解释器名称是 python3
- 相对于
Python的早期版本，这是一个 较大的升级 - 为了不带入过多的累赘，
Python 3.0在设计的时候 没有考虑向下兼容- 许多早期
Python版本设计的程序都无法在Python 3.0上正常执行
- 许多早期
- Python 3.0 发布于 2008 年
- 到目前为止，Python 3.0 的稳定版本已经有很多年了
- Python 3.3 发布于 2012
- Python 3.4 发布于 2014
- Python 3.5 发布于 2015
- Python 3.6 发布于 2016
- 为了照顾现有的程序，官方提供了一个过渡版本 —— Python 2.6
- 基本使用了
Python 2.x的语法和库 - 同时考虑了向
Python 3.0的迁移，允许使用部分Python 3.0的语法与函数 - 2010 年中推出的
Python 2.7被确定为 最后一个Python 2.x 版本
- 基本使用了
提示：如果开发时，无法立即使用 Python 3.0（还有极少的第三方库不支持 3.0 的语法），建议
- 先使用
Python 3.0版本进行开发- 然后使用
Python 2.6、Python 2.7来执行，并且做一些兼容性的处理
03. 执行 Python 程序的三种方式
3.1. 解释器 python / python3
Python 的解释器
# 使用 python 2.x 解释器
$ python xxx.py
# 使用 python 3.x 解释器
$ python3 xxx.py
其他解释器（知道）
Python 的解释器 如今有多个语言的实现，包括：
CPython—— 官方版本的 C 语言实现Jython—— 可以运行在 Java 平台IronPython—— 可以运行在 .NET 和 Mono 平台PyPy—— Python 实现的，支持 JIT 即时编译
3.2. 交互式运行 Python 程序
- 直接在终端中运行解释器，而不输入要执行的文件名
- 在 Python 的
Shell中直接输入 Python 的代码，会立即看到程序执行结果
1) 交互式运行 Python 的优缺点
优点
- 适合于学习/验证 Python 语法或者局部代码
缺点
- 代码不能保存
- 不适合运行太大的程序
2) 退出 官方的解释器
1> 直接输入 exit()
>>> exit()
2> 使用热键退出
在 python 解释器中，按热键 ctrl + d 可以退出解释器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gYvN3Hhk-1630805410386)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day01_markdown/markdown/media/14950456888393/001_积跬步以至千里.jpg)]
3) IPython
- IPython 中 的 “I” 代表 交互 interactive
特点
- IPython 是一个 python 的 交互式 shell，比默认的
python shell好用得多- 支持自动补全
- 自动缩进
- 支持
bash shell命令 - 内置了许多很有用的功能和函数
- IPython 是基于 BSD 开源的
版本
-
Python 2.x 使用的解释器是 ipython
-
Python 3.x 使用的解释器是 ipython3
-
要退出解释器可以有以下两种方式：
1> 直接输入 exit
In [1]: exit
2> 使用热键退出
在 IPython 解释器中，按热键 ctrl + d，IPython 会询问是否退出解释器
IPython 的安装
$ sudo apt install ipython
3.3. Python 的 IDE —— PyCharm
1） 集成开发环境（IDE）
集成开发环境（IDE，Integrated Development Environment）—— 集成了开发软件需要的所有工具，一般包括以下工具：
- 图形用户界面
- 代码编辑器（支持 代码补全／自动缩进）
- 编译器／解释器
- 调试器（断点／单步执行）
- ……
2）PyCharm 介绍
PyCharm是 Python 的一款非常优秀的集成开发环境PyCharm除了具有一般 IDE 所必备功能外，还可以在Windows、Linux、macOS下使用PyCharm适合开发大型项目- 一个项目通常会包含 很多源文件
- 每个 源文件 的代码行数是有限的，通常在几百行之内
- 每个 源文件 各司其职，共同完成复杂的业务功能
3）PyCharm 快速体验
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KWbkixGn-1630805410386)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day01_markdown/markdown/media/14950456888393/001_PyCharm的界面结构.png)]
- 文件导航区域 能够 浏览／定位／打开 项目文件
- 文件编辑区域 能够 编辑 当前打开的文件
- 控制台区域 能够：
- 输出程序执行内容
- 跟踪调试代码的执行
- 右上角的 工具栏 能够 执行(SHIFT + F10) / 调试(SHIFT + F9) 代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NLgnrRi3-1630805410386)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day01_markdown/markdown/media/14950456888393/002_PyCharm运行工具栏.png)]
- 通过控制台上方的单步执行按钮(F8)，可以单步执行代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AhybAsJO-1630805410387)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day01_markdown/markdown/media/14950456888393/003_PyCharm调试器.png)]
多文件项目的演练
- 开发 项目 就是开发一个 专门解决一个复杂业务功能的软件
- 通常每 一个项目 就具有一个 独立专属的目录，用于保存 所有和项目相关的文件
- 一个项目通常会包含 很多源文件
目标
- 在项目中添加多个文件，并且设置文件的执行
多文件项目演练
- 在
01_Python基础项目中新建一个hm_02_第2个Python程序.py - 在
hm_02_第2个Python程序.py文件中添加一句print("hello") - 点击右键执行
hm_02_第2个Python程序.py
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BgJERL4X-1630805410387)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day02_markdown/markdown/media/14957760846222/001_让选中的程序可以执行.png)]
提示
- 在
PyCharm中，要想让哪一个Python程序能够执行，必须首先通过 鼠标右键的方式执行 一下 - 对于初学者而言，在一个项目中设置多个程序可以执行，是非常方便的，可以方便对不同知识点的练习和测试
- 对于商业项目而言，通常在一个项目中，只有一个 可以直接执行的 Python 源程序
注释
目标
- 注释的作用
- 单行注释（行注释）
- 多行注释（块注释）
01. 注释的作用
使用用自己熟悉的语言，在程序中对某些代码进行标注说明，增强程序的可读性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sILp4H7G-1630805410388)(E:/编程之路/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/课程讲义/day02_markdown/markdown/media/14957651506944/001_未使用注释的python程序.gif)]
02. 单行注释(行注释)
-
以
#开头，#右边的所有东西都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用 -
示例代码如下：
# 这是第一个单行注释
print("hello python")
为了保证代码的可读性，
#后面建议先添加一个空格，然后再编写相应的说明文字
在代码后面增加的单行注释
-
在程序开发时，同样可以使用
#在代码的后面（旁边）增加说明性的文字 -
但是，需要注意的是，为了保证代码的可读性，注释和代码之间 至少要有 两个空格
-
示例代码如下：
print("hello python") # 输出 `hello python`
03. 多行注释（块注释）
-
如果希望编写的 注释信息很多，一行无法显示，就可以使用多行注释
-
要在 Python 程序中使用多行注释，可以用 一对 连续的 三个 引号(单引号和双引号都可以)
-
示例代码如下：
"""
这是一个多行注释
在多行注释之间，可以写很多很多的内容……
"""
print("hello python")
什么时候需要使用注释？
- 注释不是越多越好，对于一目了然的代码，不需要添加注释
- 对于 复杂的操作，应该在操作开始前写上若干行注释
- 对于 不是一目了然的代码，应在其行尾添加注释（为了提高可读性，注释应该至少离开代码 2 个空格）
- 绝不要描述代码，假设阅读代码的人比你更懂 Python，他只是不知道你的代码要做什么
在一些正规的开发团队，通常会有 代码审核 的惯例，就是一个团队中彼此阅读对方的代码
关于代码规范
Python官方提供有一系列 PEP（Python Enhancement Proposals） 文档- 其中第 8 篇文档专门针对 Python 的代码格式 给出了建议，也就是俗称的 PEP 8
- 文档地址：https://www.python.org/dev/peps/pep-0008/
- 谷歌有对应的中文文档：http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/
任何语言的程序员，编写出符合规范的代码，是开始程序生涯的第一步
算数运算符
计算机，顾名思义就是负责进行 数学计算 并且 存储计算结果 的电子设备
目标
- 算术运算符的基本使用
01. 算数运算符
- 算数运算符是 运算符的一种
- 是完成基本的算术运算使用的符号，用来处理四则运算
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 10 + 20 = 30 |
| - | 减 | 10 - 20 = -10 |
| * | 乘 | 10 * 20 = 200 |
| / | 除 | 10 / 20 = 0.5 |
| // | 取整除 | 返回除法的整数部分（商） 9 // 2 输出结果 4 |
| % | 取余数 | 返回除法的余数 9 % 2 = 1 |
| ** | 幂 | 又称次方、乘方，2 ** 3 = 8 |
- 在 Python 中
*运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果
In [1]: "-" * 50
Out[1]: '----------------------------------------'
02. 算数运算符的优先级
-
和数学中的运算符的优先级一致，在 Python 中进行数学计算时，同样也是：
- 先乘除后加减
- 同级运算符是 从左至右 计算
- 可以使用
()调整计算的优先级
-
以下表格的算数优先级由高到最低顺序排列
| 运算符 | 描述 |
|---|---|
| ** | 幂 (最高优先级) |
| * / % // | 乘、除、取余数、取整除 |
| + - | 加法、减法 |
- 例如：
2 + 3 * 5 = 17(2 + 3) * 5 = 252 * 3 + 5 = 112 * (3 + 5) = 16
"""
在控制台依次提示用户输入：姓名、公司、职位、电话、电子邮箱
"""
name = input("请输入姓名：")
company = input("请输入公司：")
title = input("请输入职位：")
phone = input("请输入电话：")
email = input("请输入邮箱：")
print("*" * 50)
print(company)
print()
print("%s (%s)" % (name, title))
print()
print("电话：%s" % phone)
print("邮箱：%s" % email)
print("*" * 50)
变量的命名
目标
- 标识符和关键字
- 变量的命名规则
0.1 标识符和关键字
1.1 标识符
标示符就是程序员定义的 变量名、函数名
名字 需要有 见名知义 的效果
- 标示符可以由 字母、下划线 和 数字 组成
- 不能以数字开头
- 不能与关键字重名
思考：下面的标示符哪些是正确的，哪些不正确为什么？
fromNo12
from#12
my_Boolean
my-Boolean
Obj2
2ndObj
myInt
My_tExt
_test
test!32
haha(da)tt
jack_rose
jack&rose
GUI
G.U.I
1.2 关键字
- 关键字 就是在
Python内部已经使用的标识符 - 关键字 具有特殊的功能和含义
- 开发者 不允许定义和关键字相同的名字的标示符
通过以下命令可以查看 Python 中的关键字
In [1]: import keyword
In [2]: print(keyword.kwlist)
提示：关键字的学习及使用，会在后面的课程中不断介绍
import关键字 可以导入一个 “工具包”在
Python中不同的工具包，提供有不同的工具
02. 变量的命名规则
命名规则 可以被视为一种 惯例，并无绝对与强制
目的是为了 增加代码的识别和可读性
注意 Python 中的 标识符 是 区分大小写的
-
在定义变量时，为了保证代码格式，
=的左右应该各保留一个空格 -
在
Python中，如果 变量名 需要由 二个 或 多个单词 组成时，可以按照以下方式命名- 每个单词都使用小写字母
- 单词与单词之间使用
_下划线 连接
- 例如：
first_name、last_name、qq_number、qq_password
驼峰命名法
- 当 变量名 是由二个或多个单词组成时，还可以利用驼峰命名法来命名
- 小驼峰式命名法
- 第一个单词以小写字母开始，后续单词的首字母大写
- 例如：
firstName、lastName
- 大驼峰式命名法
- 每一个单词的首字母都采用大写字母
- 例如：
FirstName、LastName、CamelCase
判断（if）语句
目标
- 开发中的应用场景
- if 语句体验
- if 语句进阶
- 综合应用
01. 开发中的应用场景
生活中的判断几乎是无所不在的，我们每天都在做各种各样的选择，如果这样？如果那样？……
程序中的判断
if 今天发工资:
先还信用卡的钱
if 有剩余:
又可以happy了，O(∩_∩)O哈哈~
else:
噢，no。。。还的等30天
else:
盼着发工资
判断的定义
- 如果 条件满足，才能做某件事情，
- 如果 条件不满足，就做另外一件事情，或者什么也不做
正是因为有了判断，才使得程序世界丰富多彩，充满变化！
判断语句 又被称为 “分支语句”，正是因为有了判断，才让程序有了很多的分支
02. if 语句体验
2.1 if 判断语句基本语法
在 Python 中，if 语句 就是用来进行判断的，格式如下：
if 要判断的条件:
条件成立时，要做的事情
……
注意：代码的缩进为一个
tab键，或者 4 个空格 —— 建议使用空格
- 在 Python 开发中，Tab 和空格不要混用！
我们可以把整个 if 语句看成一个完整的代码块
2.2 判断语句演练 —— 判断年龄
需求
- 定义一个整数变量记录年龄
- 判断是否满 18 岁 （>=）
- 如果满 18 岁，允许进网吧嗨皮
# 1. 定义年龄变量
age = 18
# 2. 判断是否满 18 岁
# if 语句以及缩进部分的代码是一个完整的代码块
if age >= 18:
print("可以进网吧嗨皮……")
# 3. 思考！- 无论条件是否满足都会执行
print("这句代码什么时候执行?")
注意：
if语句以及缩进部分是一个 完整的代码块
2.3 else 处理条件不满足的情况
思考
在使用 if 判断时，只能做到满足条件时要做的事情。那如果需要在 不满足条件的时候，做某些事情，该如何做呢？
答案
else，格式如下：
if 要判断的条件:
条件成立时，要做的事情
……
else:
条件不成立时，要做的事情
……
注意：
if和else语句以及各自的缩进部分共同是一个 完整的代码块
2.4 判断语句演练 —— 判断年龄改进
需求
- 输入用户年龄
- 判断是否满 18 岁 （>=）
- 如果满 18 岁，允许进网吧嗨皮
- 如果未满 18 岁，提示回家写作业
# 1. 输入用户年龄
age = int(input("今年多大了？"))
# 2. 判断是否满 18 岁
# if 语句以及缩进部分的代码是一个完整的语法块
if age >= 18:
print("可以进网吧嗨皮……")
else:
print("你还没长大，应该回家写作业！")
# 3. 思考！- 无论条件是否满足都会执行
print("这句代码什么时候执行?")
03. 逻辑运算
- 在程序开发中，通常 在判断条件时，会需要同时判断多个条件
- 只有多个条件都满足，才能够执行后续代码，这个时候需要使用到 逻辑运算符
- 逻辑运算符 可以把 多个条件 按照 逻辑 进行 连接，变成 更复杂的条件
- Python 中的 逻辑运算符 包括：与 and／或 or／非 not 三种
3.1 and
条件1 and 条件2
- 与／并且
- 两个条件同时满足，返回
True - 只要有一个不满足，就返回
False
| 条件 1 | 条件 2 | 结果 |
|---|---|---|
| 成立 | 成立 | 成立 |
| 成立 | 不成立 | 不成立 |
| 不成立 | 成立 | 不成立 |
| 不成立 | 不成立 | 不成立 |
3.2 or
条件1 or 条件2
- 或／或者
- 两个条件只要有一个满足，返回
True - 两个条件都不满足，返回
False
| 条件 1 | 条件 2 | 结果 |
|---|---|---|
| 成立 | 成立 | 成立 |
| 成立 | 不成立 | 成立 |
| 不成立 | 成立 | 成立 |
| 不成立 | 不成立 | 不成立 |
3.3 not
not 条件
- 非／不是
| 条件 | 结果 |
|---|---|
| 成立 | 不成立 |
| 不成立 | 成立 |
逻辑运算演练
- 练习1: 定义一个整数变量
age，编写代码判断年龄是否正确- 要求人的年龄在 0-120 之间
- 练习2: 定义两个整数变量
python_score、c_score，编写代码判断成绩- 要求只要有一门成绩 > 60 分就算合格
- 练习3: 定义一个布尔型变量
is_employee，编写代码判断是否是本公司员工- 如果不是提示不允许入内
答案 1：
# 练习1: 定义一个整数变量 age，编写代码判断年龄是否正确age = 100# 要求人的年龄在 0-120 之间if age >= 0 and age <= 120: print("年龄正确")else: print("年龄不正确")
答案 2：
# 练习2: 定义两个整数变量 python_score、c_score，编写代码判断成绩python_score = 50c_score = 50# 要求只要有一门成绩 > 60 分就算合格if python_score > 60 or c_score > 60: print("考试通过")else: print("再接再厉！")
答案 3：
# 练习3: 定义一个布尔型变量 `is_employee`，编写代码判断是否是本公司员工is_employee = True# 如果不是提示不允许入内if not is_employee: print("非公勿内")
04. if 语句进阶
4.1 elif
- 在开发中，使用
if可以 判断条件 - 使用
else可以处理 条件不成立 的情况 - 但是，如果希望 再增加一些条件，条件不同，需要执行的代码也不同 时，就可以使用
elif - 语法格式如下：
if 条件1: 条件1满足执行的代码 ……elif 条件2: 条件2满足时，执行的代码 ……elif 条件3: 条件3满足时，执行的代码 ……else: 以上条件都不满足时，执行的代码 ……
- 对比逻辑运算符的代码
if 条件1 and 条件2: 条件1满足 并且 条件2满足 执行的代码 ……
注意
elif和else都必须和if联合使用，而不能单独使用- 可以将
if、elif和else以及各自缩进的代码，看成一个 完整的代码块
elif 演练 —— 女友的节日
需求
- 定义
holiday_name字符串变量记录节日名称 - 如果是 情人节 应该 买玫瑰／看电影
- 如果是 平安夜 应该 买苹果／吃大餐
- 如果是 生日 应该 买蛋糕
- 其他的日子每天都是节日啊……
holiday_name = "平安夜"if holiday_name == "情人节": print("买玫瑰") print("看电影")elif holiday_name == "平安夜": print("买苹果") print("吃大餐")elif holiday_name == "生日": print("买蛋糕")else: print("每天都是节日啊……")
4.2 if 的嵌套
elif 的应用场景是：同时 判断 多个条件，所有的条件是 平级 的
- 在开发中，使用
if进行条件判断，如果希望 在条件成立的执行语句中 再 增加条件判断，就可以使用 if 的嵌套 - if 的嵌套 的应用场景就是：在之前条件满足的前提下，再增加额外的判断
- if 的嵌套 的语法格式，除了缩进之外 和之前的没有区别
- 语法格式如下：
if 条件 1: 条件 1 满足执行的代码 …… if 条件 1 基础上的条件 2: 条件 2 满足时，执行的代码 …… # 条件 2 不满足的处理 else: 条件 2 不满足时，执行的代码 # 条件 1 不满足的处理else: 条件1 不满足时，执行的代码 ……
if 的嵌套 演练 —— 火车站安检
需求
- 定义布尔型变量
has_ticket表示是否有车票 - 定义整型变量
knife_length表示刀的长度，单位：厘米 - 首先检查是否有车票，如果有，才允许进行 安检
- 安检时，需要检查刀的长度，判断是否超过 20 厘米
- 如果超过 20 厘米，提示刀的长度，不允许上车
- 如果不超过 20 厘米，安检通过
- 如果没有车票，不允许进门
# 定义布尔型变量 has_ticket 表示是否有车票has_ticket = True# 定义整数型变量 knife_length 表示刀的长度，单位：厘米knife_length = 20# 首先检查是否有车票，如果有，才允许进行 安检if has_ticket: print("有车票，可以开始安检...") # 安检时，需要检查刀的长度，判断是否超过 20 厘米 # 如果超过 20 厘米，提示刀的长度，不允许上车 if knife_length >= 20: print("不允许携带 %d 厘米长的刀上车" % knife_length) # 如果不超过 20 厘米，安检通过 else: print("安检通过，祝您旅途愉快……")# 如果没有车票，不允许进门else: print("大哥，您要先买票啊")
05. 综合应用 —— 石头剪刀布
目标
- 强化 多个条件 的 逻辑运算
- 体会
import导入模块（“工具包”）的使用
需求
- 从控制台输入要出的拳 —— 石头（1）／剪刀（2）／布（3）
- 电脑 随机 出拳 —— 先假定电脑只会出石头，完成整体代码功能
- 比较胜负
| 序号 | 规则 |
|---|---|
| 1 | 石头 胜 剪刀 |
| 2 | 剪刀 胜 布 |
| 3 | 布 胜 石头 |
5.1 基础代码实现
- 先 假定电脑就只会出石头，完成整体代码功能
# 从控制台输入要出的拳 —— 石头（1）／剪刀（2）／布（3）player = int(input("请出拳 石头（1）／剪刀（2）／布（3）："))# 电脑 随机 出拳 - 假定电脑永远出石头computer = 1# 比较胜负# 如果条件判断的内容太长，可以在最外侧的条件增加一对大括号# 再在每一个条件之间，使用回车，PyCharm 可以自动增加 8 个空格if ((player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1)): print("噢耶！！！电脑弱爆了！！！")elif player == computer: print("心有灵犀，再来一盘！")else: print("不行，我要和你决战到天亮！")
5.2 随机数的处理
- 在
Python中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”
import random
-
导入模块后，可以直接在 模块名称 后面敲一个
.然后按Tab键，会提示该模块中包含的所有函数 -
random.randint(a, b)，返回[a, b]之间的整数，包含a和b -
例如：
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20 random.randint(20, 20) # 结果永远是 20 random.randint(20, 10) # 该语句是错误的，下限必须小于上限
运算符
目标
- 算数运算符
- 比较（关系）运算符
- 逻辑运算符
- 赋值运算符
- 运算符的优先级
数学符号表链接：https://zh.wikipedia.org/wiki/数学符号表
01. 算数运算符
- 是完成基本的算术运算使用的符号，用来处理四则运算
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 10 + 20 = 30 |
| - | 减 | 10 - 20 = -10 |
| * | 乘 | 10 * 20 = 200 |
| / | 除 | 10 / 20 = 0.5 |
| // | 取整除 | 返回除法的整数部分（商） 9 // 2 输出结果 4 |
| % | 取余数 | 返回除法的余数 9 % 2 = 1 |
| ** | 幂 | 又称次方、乘方，2 ** 3 = 8 |
- 在 Python 中
*运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果
In [1]: "-" * 50
Out[1]: '----------------------------------------'
02. 比较（关系）运算符
| 运算符 | 描述 |
|---|---|
| == | 检查两个操作数的值是否 相等，如果是，则条件成立，返回 True |
| != | 检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True |
| > | 检查左操作数的值是否 大于 右操作数的值，如果是，则条件成立，返回 True |
| < | 检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True |
| >= | 检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True |
| <= | 检查左操作数的值是否 小于或等于 右操作数的值，如果是，则条件成立，返回 True |
Python 2.x 中判断 不等于 还可以使用
<>运算符
!=在 Python 2.x 中同样可以用来判断 不等于
03. 逻辑运算符
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 只有 x 和 y 的值都为 True，才会返回 True 否则只要 x 或者 y 有一个值为 False，就返回 False |
| or | x or y | 只要 x 或者 y 有一个值为 True，就返回 True 只有 x 和 y 的值都为 False，才会返回 False |
| not | not x | 如果 x 为 True，返回 False 如果 x 为 False，返回 True |
04. 赋值运算符
- 在 Python 中，使用
=可以给变量赋值 - 在算术运算时，为了简化代码的编写，
Python还提供了一系列的 与 算术运算符 对应的 赋值运算符 - 注意：赋值运算符中间不能使用空格
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
| %= | 取 模 (余数)赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
05. 运算符的优先级
- 以下表格的算数优先级由高到最低顺序排列
| 运算符 | 描述 |
|---|---|
| ** | 幂 (最高优先级) |
| * / % // | 乘、除、取余数、取整除 |
| + - | 加法、减法 |
| <= < > >= | 比较运算符 |
| == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| not or and | 逻辑运算符 |
循环
目标
- 程序的三大流程
- while 循环基本使用
- break 和 continue
- while 循环嵌套
01. 程序的三大流程
-
在程序开发中，一共有三种流程方式：
- 顺序 —— 从上向下，顺序执行代码
- 分支 —— 根据条件判断，决定执行代码的 分支
- 循环 —— 让 特定代码 重复 执行
02. while 循环基本使用
-
循环的作用就是让 指定的代码 重复的执行
-
while循环最常用的应用场景就是 让执行的代码 按照 指定的次数 重复 执行 -
需求 —— 打印 5 遍
Hello Python -
思考 —— 如果要求打印 100 遍怎么办？
2.1 while 语句基本语法
初始条件设置 —— 通常是重复执行的 计数器
while 条件(判断 计数器 是否达到 目标次数):
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
处理条件(计数器 + 1)
注意：
while语句以及缩进部分是一个 完整的代码块
第一个 while 循环
需求
- 打印 5 遍 Hello Python
# 1. 定义重复次数计数器
i = 1
# 2. 使用 while 判断条件
while i <= 5:
# 要重复执行的代码
print("Hello Python")
# 处理计数器 i
i = i + 1
print("循环结束后的 i = %d" % i)
注意：循环结束后，之前定义的计数器条件的数值是依旧存在的
死循环
由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执行，程序无法终止！
2.2 赋值运算符
- 在 Python 中，使用
=可以给变量赋值 - 在算术运算时，为了简化代码的编写，
Python还提供了一系列的 与 算术运算符 对应的 赋值运算符 - 注意：赋值运算符中间不能使用空格
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
| %= | 取 模 (余数)赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
2.3 Python 中的计数方法
常见的计数方法有两种，可以分别称为：
- 自然计数法（从
1开始）—— 更符合人类的习惯 - 程序计数法（从
0开始）—— 几乎所有的程序语言都选择从 0 开始计数
因此，大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始
2.4 循环计算
在程序开发中，通常会遇到 利用循环 重复计算 的需求
遇到这种需求，可以：
- 在
while上方定义一个变量，用于 存放最终计算结果 - 在循环体内部，每次循环都用 最新的计算结果，更新 之前定义的变量
需求
- 计算 0 ~ 100 之间所有数字的累计求和结果
# 计算 0 ~ 100 之间所有数字的累计求和结果
# 0. 定义最终结果的变量
result = 0
# 1. 定义一个整数的变量记录循环的次数
i = 0
# 2. 开始循环
while i <= 100:
print(i)
# 每一次循环，都让 result 这个变量和 i 这个计数器相加
result += i
# 处理计数器
i += 1
print("0~100之间的数字求和结果 = %d" % result)
需求进阶
- 计算 0 ~ 100 之间 所有 偶数 的累计求和结果
开发步骤
- 编写循环 确认 要计算的数字
- 添加 结果 变量，在循环内部 处理计算结果
# 0. 最终结果
result = 0
# 1. 计数器
i = 0
# 2. 开始循环
while i <= 100:
# 判断偶数
if i % 2 == 0:
print(i)
result += i
# 处理计数器
i += 1
print("0~100之间偶数求和结果 = %d" % result)
03. break 和 continue
break和continue是专门在循环中使用的关键字
break某一条件满足时，退出循环，不再执行后续重复的代码continue某一条件满足时，不执行后续重复的代码
break和continue只针对 当前所在循环 有效
3.1 break
- 在循环过程中，如果 某一个条件满足后，不 再希望 循环继续执行，可以使用
break退出循环
i = 0
while i < 10:
# break 某一条件满足时，退出循环，不再执行后续重复的代码
# i == 3
if i == 3:
break
print(i)
i += 1
print("over")
break只针对当前所在循环有效
3.2 continue
- 在循环过程中，如果 某一个条件满足后，不 希望 执行循环代码，但是又不希望退出循环，可以使用
continue - 也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行
i = 0
while i < 10:
# 当 i == 7 时，不希望执行需要重复执行的代码
if i == 7:
# 在使用 continue 之前，同样应该修改计数器
# 否则会出现死循环
i += 1
continue
# 重复执行的代码
print(i)
i += 1
- 需要注意：使用
continue时，条件处理部分的代码，需要特别注意，不小心会出现 死循环
continue只针对当前所在循环有效
04. while 循环嵌套
4.1 循环嵌套
while嵌套就是：while里面还有while
while 条件 1:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
while 条件 2:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
处理条件 2
处理条件 1
4.2 循环嵌套演练 —— 九九乘法表
第 1 步：用嵌套打印小星星
需求
- 在控制台连续输出五行
*，每一行星号的数量依次递增
*
**
***
****
*****
- 使用字符串 * 打印
# 1. 定义一个计数器变量，从数字1开始，循环会比较方便
row = 1
while row <= 5:
print("*" * row)
row += 1
第 2 步：使用循环嵌套打印小星星
知识点 对 print 函数的使用做一个增强
-
在默认情况下，
print函数输出内容之后，会自动在内容末尾增加换行 -
如果不希望末尾增加换行，可以在
print函数输出内容的后面增加, end="" -
其中
""中间可以指定print函数输出内容之后，继续希望显示的内容 -
语法格式如下：
# 向控制台输出内容结束之后，不会换行
print("*", end="")
# 单纯的换行
print("")
end=""表示向控制台输出内容结束之后，不会换行
假设 Python 没有提供 字符串的 * 操作 拼接字符串
需求
- 在控制台连续输出五行
*，每一行星号的数量依次递增
*
**
***
****
*****
开发步骤
- 1> 完成 5 行内容的简单输出
- 2> 分析每行内部的
*应该如何处理？- 每行显示的星星和当前所在的行数是一致的
- 嵌套一个小的循环，专门处理每一行中
列的星星显示
row = 1
while row <= 5:
# 假设 python 没有提供字符串 * 操作
# 在循环内部，再增加一个循环，实现每一行的 星星 打印
col = 1
while col <= row:
print("*", end="")
col += 1
# 每一行星号输出完成后，再增加一个换行
print("")
row += 1
第 3 步： 九九乘法表
需求 输出 九九乘法表，格式如下：
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
开发步骤
-
- 打印 9 行小星星
*
**
***
****
*****
******
*******
********
*********
-
- 将每一个
*替换成对应的行与列相乘
- 将每一个
# 定义起始行row = 1# 最大打印 9 行while row <= 9: # 定义起始列 col = 1 # 最大打印 row 列 while col <= row: # end = ""，表示输出结束后，不换行 # "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐 print("%d * %d = %d" % (col, row, row * col), end="\t") # 列数 + 1 col += 1 # 一行打印完成的换行 print("") # 行数 + 1 row += 1
字符串中的转义字符
\t在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐\n在控制台输出一个 换行符
制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本
| 转义字符 | 描述 |
|---|---|
| \\ | 反斜杠符号 |
| \’ | 单引号 |
| \" | 双引号 |
| \n | 换行 |
| \t | 横向制表符 |
| \r | 回车 |
980
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
