解释型语言
解释型语言，是在运行的时候将程序翻译成机器语言。
解释型语言的程序不需要在运行前编译，在运行程序的时候才翻译，专门的解释器负责在每个语句执行的时候解释程序代码。这样解释型语言每执行一次就要翻译一次，效率比较低。
计算机不能直接理解任何除机器语言以外的语言，所以必须要把程序员所写的程序语言翻译成机器语言，计算机才能执行程序。将其他语言翻译成机器语言的工具，被称为编译器。
编译器翻译的方式有两种：一个是编译，一个是解释。两种方式之间的区别在于翻译时间点的不同。当编译器以解释方式运行的时候，也称之为解释器。
解释性语言编写的程序不进行预先编译，以文本方式存储程序代码。在发布程序时，看起来省了道编译工序。但是，在运行程序的时候，解释性语言必须先解释再运行。比如解释性Basic语言，其专用的解释器在执行Basic程序时，会逐条读取解释每个语句，这个其实就是一个编译过程，然后再执行。一般来说，现有的解释性语言都是采用的逐行解释一句，执行一句这样的方式来构建的。这样解释性语言每执行一次就要翻译一次，效率比较低。
解释型语言优缺点
编译型与解释型，两者各有利弊。前者由于程序执行速度快，同等条件下对系统要求较低，因此像开发操作系统、大型应用程序、数据库系统等时都采用它，像C/C++、Pascal/Object Pascal（Delphi）等都是编译语言，而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言，如JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等等。
但随着硬件的升级和设计思想的变革，编译型和解释型语言越来越笼统，主要体现在一些新兴的高级语言上，而解释型语言的自身特点也使得编译器厂商愿意花费更多成本来优化解释器，解释型语言性能超过编译型语言也是必然的。
解释性语言，如Java，往往会有较慢的运行速度，有时需要C++等语言的3倍 [2] 。
和编译性语言的区别
计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。
翻译的方式有两种，一个是编译，一个是解释。两种方式只是翻译的时间不同。编译型语言写的程序执行之前，需要一个专门的编译过程，把程序编译成为机器语言的文件，比如exe文件，以后要运行的话就不用重新翻译了，直接使用编译的结果就行了（exe文件），因为翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高，但也不能一概而论，部分解释型语言的解释器通过在运行时动态优化代码，甚至能够使解释型语言的性能超过编译型语言。
解释则不同，解释性语言的程序不需要编译，省了道工序，解释性语言在运行程序的时候才翻译，比如解释性basic语言，专门有一个解释器能够直接执行basic程序，每个语句都是执行的时候才翻译。这样解释性语言每执行一次就要翻译一次，效率比较低。解释是一句一句的翻译。
编译型与解释型，两者各有利弊。前者由于程序执行速度快，同等条件下对系统要求较低，因此像开发操作系统、大型应用程序、数据库系统等时都采用它，像C/C++、Pascal/Object Pascal（Delphi）等都是编译语言，而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言，如Java、JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等等。
但随着硬件的升级和设计思想的变革，编译型和解释型语言越来越笼统，主要体现在一些新兴的高级语言上，而解释型语言的自身特点也使得编译器厂商愿意花费更多成本来优化解释器，解释型语言性能超过编译型语言也是必然的。
Python 简介
语言是人类最重要的交际工具，是人类之间进行信息交换的主要表达方式。
编程语言是用来定义计算机程序的语言，用来向计算机发出指令。
Python 语言是一种面向对象的解释性计算机程序设计语言。
Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆 于1990 年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言， [2] 随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。
吉多·范罗苏姆*（Guido van Rossum）* ，是一名荷兰计算机程序员，他作为 Python 程序设计语言的作者而为人们熟知。在 Python 社区，吉多·范罗苏姆被人们认为是“仁慈的独裁者（BDFL）”，意思是他仍然关注 Python 的开发进程，并在必要的时刻做出决定。他在 Google 工作，在那里他把一半的时间用来维护 Python 的开发。
2020年11月12日， Python之父Guido van Rossum在自己的官方宣布：由于退休生活太无聊，自己决定加入Microsoft 的 DevDiv Team。
Python解释器易于扩展，可以使用C语言或C++（或者其他可以通过C调用的语言）扩展新的功能和数据类型。 Python 也可用于可定制化软件中的扩展程序语言。Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码。
2021年10月，语言流行指数的编译器Tiobe将Python加冕为最受欢迎的编程语言，20年来首次将其置于Java、C和JavaScript之上。
优点
简单：Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样。它使你能够专注于解决问题而不是去搞明白语言本身。
易学：Python极其容易上手，因为Python有极其简单的说明文档 。
易读、易维护：风格清晰划一、强制缩进。
用途广泛
**速度快：**Python 的底层是用 C 语言写的，很多标准库和第三方库也都是用 C 写的，运行速度非常快。免费、开源：Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。
高层语言：用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。
可移植性：由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE、PocketPC、Symbian以及Google基于linux开发的android平台。
解释性：一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。
运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行 程序。
在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。这使得使用Python更加简单。也使得Python程序更加易于移植。
面向对象：Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。
Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。
可扩展性、可扩充性：如果需要一段关键代码运行得更快或者希望某些算法不公开，可以部分程序用C或C++编写，然后在Python程序中使用它们。
Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此，很多人还把Python作为一种“胶水语言”（glue language）使用。使用Python将其他语言编写的程序进行集成和封装。在Google内部的很多项目，例如Google Engine使用C++编写性能要求极高的部分，然后用Python或Java/Go调用相应的模块。《Python技术手册》的作者马特利（Alex Martelli）说：“这很难讲，不过，2004 年，Python 已在Google 内部使用，Google 召募许多 Python 高手，但在这之前就已决定使用Python，他们的目的是 Python where we can, C++ where we must，在操控硬件的场合使用C++，在快速开发时候使用 Python。”
可嵌入性：可以把Python嵌入C/C++程序，从而向程序用户提供脚本功能。
丰富的库：Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
**规范的代码：**Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。Python的作者设计限制性很强的语法，使得不好的编程习惯（例如if语句的下一行不向右缩进）都不能通过编译。其中很重要的一项就是Python的缩进规则。一个和其他大多数语言（如C）的区别就是，一个模块的界限，完全是由每行的首字符在这一行的位置来决定（而C语言是用一对大括号“{}”（不含引号）来明确的定出模块的边界，与字符的位置毫无关系）。通过强制程序员们缩进（包括if，for和函数定义等所有需要使用模块的地方），Python确实使得程序更加清晰和美观。
**高级动态编程：**虽然Python可能被粗略地分类为“脚本语言”（script language），但实际上一些大规模软件开发计划例如Zope、Mnet及BitTorrent，Google也广泛地使用它。Python的支持者较喜欢称它为一种高级动态编程语言，原因是“脚本语言”泛指仅作简单程序设计任务的语言，如shellscript、VBScript等只能处理简单任务的编程语言，并不能与Python相提并论。
**做科学计算优点多：**说起科学计算，首先会被提到的可能是MATLAB。除了MATLAB的一些专业性很强的工具箱还无法被替代之外，MATLAB的大部分常用功能都可以在Python世界中找到相应的扩展库。和MATLAB相比，用Python做科学计算有如下优点：
- 首先，MATLAB是一款商用软件，并且价格不菲。而Python完全免费，众多开源的科学计算库都提供了Python的调用接口。用户可以在任何计算机上免费安装Python及其绝大多数扩展库。
- 其次，与MATLAB相比，Python是一门更易学、更严谨的程序设计语言。它能让用户编写出更易读、易维护的代码。
- 最后，MATLAB主要专注于工程和科学计算。然而即使在计算领域，也经常会遇到文件管理、界面设计、网络通信等各种需求。而Python有着丰富的扩展库，可以轻易完成各种高级任务，开发者可以用Python实现完整应用程序所需的各种功能。
缺点
单行语句和**命令行**输出问题：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。
**给初学者带来困惑：独特的语法，**这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中。
运行速度慢：这里是指与C和C++相比。Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。所以很多人认为Python很慢。不过，根据二八定律，大多数程序对速度要求不高。在某些对运行速度要求很高的情况，Python设计师倾向于使用JIT技术，或者用使用C/C++语言改写这部分程序。可用的JIT技术是PyPy。
和其他语言区别
对于一个特定的问题，只要有一种最好的方法来解决
这在由Tim Peters写的Python格言（称为The Zen of Python）里面表述为：There should be one-- and preferably only one --obvious way to do it. 这正好和Perl语言（另一种功能类似的高级动态语言）的中心思想TMTOWTDI（There’s More Than One Way To Do It）完全相反。
Python的设计哲学是“优雅”、“明确”、“简单”。因此，Perl语言中“总是有多种方法来做同一件事”的理念在Python开发者中通常是难以忍受的。Python开发者的哲学是“用一种方法，最好是只有一种方法来做一件事”。在设计Python语言时，如果面临多种选择，Python开发者一般会拒绝花俏的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常被认为比Perl具备更好的可读性，并且能够支撑大规模的软件开发。这些准则被称为Python格言。在Python解释器内运行import this可以获得完整的列表。
更高级的Virtual Machine
Python在执行时，首先会将.py文件中的源代码编译成Python的byte code（字节码），然后再由Python Virtual Machine（Python虚拟机）来执行这些编译好的byte code。这种机制的基本思想跟Java，.NET是一致的。然而，Python Virtual Machine与Java或.NET的Virtual Machine不同的是，Python的Virtual Machine是一种更高级的Virtual Machine。这里的高级并不是通常意义上的高级，不是说Python的Virtual Machine比Java或.NET的功能更强大，而是说和Java 或.NET相比，Python的Virtual Machine距离真实机器的距离更远。或者可以这么说，Python的Virtual Machine是一种抽象层次更高的Virtual Machine。基于C的Python编译出的字节码文件，通常是.pyc格式。除此之外，Python还可以以交互模式运行，比如主流操作系统Unix/Linux、Mac、Windows都可以直接在命令模式下直接运行Python交互环境。直接下达操作指令即可实现交互操作。
Python 入门
Python 解释器安装
- 官网：https://www.python.org/
- 解释器下载地址：https://www.python.org/downloads/
- 双击安装
- 第一个选项默认安装到C盘，需勾选添加到系统环境变量
- 第二个可自行选择安装地址（默认选项即可）
Python 继承开发环境安装
- PyCharm官网：https://www.jetbrains.com/zh-cn/pycharm/
- 软件下载地址：https://www.jetbrains.com/zh-cn/pycharm/download/
- 历史版本下载地址：https://www.jetbrains.com/zh-cn/pycharm/download/other.html
第一个 Python 程序
Hello Python
# hello python
print("hello python")
Python 基础
注释
# 单行注释
print("hello python")
"""
多行注释
"""
print("hello python")
算数运算符
"""
演示: +、-、*、/、//（整除）、%（取模）、**（次幂）
运算顺序:
先次幂,后乘除
先乘除,后加减
"""
print(1 + 2) # 3
print(3 - 2) # 1
print(2 * 4) # 8
print(11 / 4) # 2.75
print(11 // 4) # 2
print(11 % 4) # 3
print(3 ** 2) # 9
print(2 * 3 ** 2) # 18
print(3 ** 2 * 2) # 18
变量
概念
描述计算机中的数据存储空间。
作用
在计算机内存中保存数据。
保存数据的格式：变量名 = 值
注意事项
首次使用在内存中划分空间，并初始化值；再次使用不再划分空间，修改原空间中的值。
定义变量
a = 1
b = 2
print(1 + 2)
c = 3.2
print(c)
str1 = "哈哈哈"
print(str1)
变量命名规则
案例（计算圆的面积）
# 半径
r = 3.5
# 圆周率"π"
pi = 3.14
# 面积
area = pi * r ** 2
# 打印结果
print(area)
变量类型
特征
- 类型在使用过程中随时发生改变，以最后一次执行赋值操作的结果为准。
数值型
| 名称 |
中文名称 |
作用 |
示例 |
| int |
整形 |
整数 |
3、15、-100、2000 |
| float |
浮点型 |
小数 |
3.14、-9.25、10.0 |
| bool |
布尔型 |
逻辑值 |
True(1)、False(0) |
|
|
|
|
x = 5
y = 1.25
z = True
z1 = False
print(x) # 5
print(y) # 1.25
print(z) # True
print(z1) # False
print(x + z) # 6
print(x + z1) # 5
# 特性
age = 18
print(type(age)) # <class 'int'>
age = 18.1
print(type(age)) # <class 'float'>
age = True
print(type(age)) # <class 'bool'>
age = "十八"
print(type(age)) # <class 'str'>
赋值运算和复合赋值运算
| 符号 |
作用 |
格式 |
= |
赋值 |
a=b，将b的值给a |
+= |
加后赋值 |
a+=b，将a+b的值赋给a |
-= |
减后赋值 |
a-=b，将a-b的值赋给a |
*= |
乘后赋值 |
a*=b，将a*b的值赋给a |
/= |
除后赋值 |
a/=b，将a/b的值赋给a |
//= |
整除后赋值 |
a//=b，将a/b的值赋给a |
%= |
取余后赋值 |
a%=b，将a%b的值赋给a |
**= |
次幂后赋值 |
a**=b，将a的b次幂值赋给a |
注意：赋值运算的左侧只能是变量，右侧不限定。
字符串运算
- 字符串之间可以使用
+ 进行拼接运算
格式："A" + "B" -> "AB"
- 字符串与数值之间可以使用
* 进行反复连接运算
格式："A" * 5 -> "AAAAA"
- 字符串与数值之间不可以进行
+ 进行拼接
a = "张三"
b = "李四"
print(a + b) # 张三李四
c = 3
print(a * c) # 张三张三张三
print("a" + c) # 报错:print("a" + c) # 报错:TypeError: must be str, not int
标准输入输出
输入
input() 可以用来接收用户输入的信息，当执行到 input() 操作时，程序等待用户输入，而不向下执行。
两种格式
# 标准输入函数
input()
# 使用变量接收输入值
name = input() # 张三
print(name) # 张三
# 使用变量接收输入值(给出提示信息)
name = input("请输入你的姓名:") # 请输入你的姓名:张三
print(name) # 张三
# 使用 `input()` 操作得到的数据都是 `str`（字符串）类型
a = input() # 张三
print(type(a)) # <class 'str'>
b = input() # 3
print(type(b)) # <class 'str'>
a = input() # 2
b = input() # 3
print(a + b) # 23
类型转换及注意事项
- 字符串类型的数据可以转换成其他类型的数据，但是数据必须是可转换的
-
int 类型的数据可以转换成 float 类型的数据，在原始 int 数据后面补 0
-
float 类型的数据无法转换成 int 类型的数据，无论原始数据是不是整数
# 通过类型转换，将字符串转换为数字
c = int(input()) # 2
d = int(input()) # 3
print(c + d) # 5
c = float(input()) # 2
d = float(input()) # 3
print(c + d) # 5.0
# flout 存在精度问题
c = float(input()) # 1.1
d = float(input()) # 2.2
print(c + d) # 3.3000000000000003
类型不匹配，会报错误（int 转 float 不会报错）
a = int(input("输入:")) # 输入:aa
# ValueError: invalid literal for int() with base 10: 'aa'
a = int(input("输入:")) # 输入:2.4
# ValueError: invalid literal for int() with base 10: '2.4'
a = int(input("输入:")) # 输入:2.0
# ValueError: invalid literal for int() with base 10: '2.0'
a = int(input("输入:")) # 输入:-5
# 无问题
a = int(input("输入:")) # 输入:-5+6
# ValueError: invalid literal for int() with base 10: '-5+6'
# int -》 float 不会报错
a = float(input("输入:")) # 输入:2
print(a) # 2.0
输出
将数据通过控制台显示给用户的过程。
语法格式
print(变量)print("格式化字符串" % 变量)print("格式化字符串" % (变量, 变量 ...))
print("hello python") # hello python
# 扩展：print(变量, end=值)
num = 0
while num < 5:
print(num, end="-")
num += 1
# 打印结果：0-1-2-3-4-
输出占位符
| 占位符 |
作用 |
%s |
字符串 |
%d |
整数 |
%6d |
整数，数字用于设置位数（最小值），不足位数则补空格
|
%f |
浮点数 |
%.4f |
设置小数位数，四舍五入，省略数字表示取整
|
| %% |
输出% |
name = "张三"
age = 20
print("姓名是%s" % name) # 姓名是张三
print("年龄是%d岁" % age) # 年龄是20岁
print("姓名是%s,年龄是%d岁" % (name, age)) # 姓名是张三,年龄是20岁
height = 1.78
print("身高:%f米" % height) # 身高:1.780000米
print("身高:%.2f米" % height) # 身高:1.78米
print("身高:%.3f米" % height) # 身高:1.780米
print("%s是全校成绩前20%%" % name) # 张三是全校成绩前20%
示例
使用输入输出计算圆的面积。
pi = 3.14
r = float(input("请输入圆的半径(最多两位小数):")) # 请输入圆的半径(最多两位小数):1.25
area = pi * r ** 2
print("半径为%.2f的圆的面积为%.4f" % (r, area)) # 半径为1.25的圆的面积为4.9062
比较运算符
| 符号 |
说明（成立为True，不成立为False） |
| == |
是否等于 |
| != |
是否不等于 |
| > |
是否大于 |
| < |
是否小于 |
| >= |
是否大于等于 |
| <= |
是否小于等于 |
数字比较
print(1 == 1) # True
print(1 == 2) # False
print(1 != 1) # False
print(1 != 2) # True
print(2 > 2) # False
print(2 > 1) # True
print(1 < 1) # False
print(1 < 2) # True
print(1 >= 1) # True
print(1 >= 2) # False
print(2 <= 1) # False
print(2 <= 2) # True
字符串比较
比较规则:
- 对两个字符串中对应位置每个字符逐一比对
ASCll 码
- 排序较小的整体字符串值小
- 如果比较结果相等，比较下一个字符
- 直到对比到最后一个字母
- 若对比的一方没有字符，则整体字符串值小
print("a" > "b") # False
print("b" > "a") # True
print("A" > "a") # False
print("a" > "A") # True
print("a" > "1") # True
print("a" > "127") # True 首个字符先比较,相同则比较第二个
print("aadd" > "aaddc") # False 前边相同,多位者大
关系运算符
| 符号 |
语法格式 |
说明 |
规律 |
and |
布尔表达式 and 布尔表达式 |
对两个布尔表达式进行”并且“运算 |
同真即真 |
or |
布尔表达式 or 布尔表达式 |
对两个布尔表达式进行”或者“运算 |
同假即假 |
not |
not 布尔表达式 |
对两个布尔表达式进行”取反“运算 |
非真即假，非假即真 |
print(True and True) # True
print(True and False) # False
print(False and False) # False
print(True or True) # True
print(True or False) # True
print(False or False) # False
print(not True) # False
print(not False) # True
数字参与关系运算
数字可以作为布尔表达式参与运算
-
某个操作室可以决定整个式子值的，最终结果即为该操作数
print(0 and True) # 0
print(True or 0) # True
-
两个操作数都无法单独决定整个式子值的，最终结果即为后边的操作数
print(0 or False) # False
print(-2 or False) # -2
# 0表示False,非0表示True
print(-2 and True) # True
print(0 and True) # 0
print(1 and True) # True
print(-2 and False) # False
print(0 and False) # 0
print(1 and False) # False
print(True and -2) # -2
print(True and 0) # 0
print(True and 1) # 1
print(False and -2) # False
print(False and 0) # False
print(False and 1) # False
print(-2 or True) # -2
print(0 or True) # True
print(1 or True) # 1
print(-2 or False) # -2
print(0 or False) # False
print(1 or False) # 1
print(True or -2) # True
print(True or 0) # True
print(True or 1) # True
print(False or -2) # -2
print(False or 0) # 0
print(False or 1) # 1
print(-2 or -2) # -2
print(0 or 0) # 0
print(1 or 1) # 1
print(-2 or -2) # -2
print(0 or 2) # 2
print(1 or 1) # 1
分支语句
if
if 条件:
执行代码
...
# 顺序语句
print("开始") # 开始
print("中间") # 中间
print("结束") # 结束
# 分支语句
print("开始") # 开始
if False:
print("中间1")
if True:
print("中间2") # 中间2
print("结束") # 结束
# 分支语句
print("开始") # 开始
if False:
print("中间")
print("中间")
print("结束") # 结束
# 案例:判断一个数字是不是三位的偶数
num = int(input("请输入一个三位数字："))
if 99 < num < 1000 and num % 2 == 0:
print("%d是偶数" % num)
if .. else ..
if 条件:
执行语句
...
else:
执行语句
...
# 案例:判断一个数字是不是偶数
num = int(input("请输入一个数字："))
if num % 2 == 0:
print("%d是偶数" % num)
else:
print("%d不是偶数" % num)
if .. elif .. else ..
if 条件:
执行语句
...
elif:
执行语句
...
else:
执行语句
...
elif ：条件可以多个
# 案例:判断分数情况
num = int(input("请输入一个分数（0-100）："))
if num == 100:
print("满分")
elif 80 <= num < 100:
print("优秀")
elif 60 <= num < 80:
print("及格")
else:
print("不及格")
分支嵌套
案例：判断是整数还是负数，如果是正数，判断是基数还是偶数
num = int(input("请输入一个数字："))
if num > 0:
if num % 2 != 0:
print("正数基数")
else:
print("正数偶数")
elif num == 0:
print("非整非负")
else:
print("负数")
条件超长行处理
方案一：换行出使用 \
a = 20
if a == 5 and a == 5 and a == 5 \
and a == 5 and a == 5 \
and a == 5 and a == 5 \
and a == 5 and a == 5:
print("%d等于5" % a)
方案二：对整体添加 ()，() 中随意换行
a = 20
if (a == 5 and a == 5 and a == 5
and a == 5 and a == 5
and a == 5 and a == 5
and a == 5 and a == 5):
print("%d等于5" % a)
循环语句
循环是程序设计语言中反复执行某些代码的一种计算机处理过程。
while 结构
while 条件
执行语句
...
# 案例：打印 1-5
i = 0 # 循环变量通常从 0 开始
while i < 5:
print(i)
i += 1
死循环：如果循环语句未设置合理的退出条件，则循环语句构成死循环，程序将永久执行下去。
i = 0
while i < 1:
print("死循环演示打印")
案例（打印三位回文数）
# 打印三位”回文数“
num = 100
while num <= 999:
a = num // 100
b = num % 10
if a == b:
print(num)
num += 1
循环的终止与跳出
-
break：结束当前循环
-
continue：结束本轮循环
注意：break 和 continue 必须出现在循环体中，仅能控制其所在的循环，不能控制其他循环机构（嵌套也不行）。
# 打印 1-5，遇到 3，结束本次循环（break）
num = 0
while num <= 5:
num += 1
if num == 3:
break
print("循环打印%d" % num)
# 循环打印1
# 循环打印2
# 打印 1-5，遇到 3，跳过本次循环（continue）
num = 0
while num < 5:
num += 1
if num == 3:
continue
print("循环打印%d" % num)
# 循环打印1
# 循环打印2
# 循环打印4
# 循环打印5
循环嵌套
# 打印5次 1到3
i = 0
while i < 5:
j = 1
while j <= 3:
print(j, end=" ")
j += 1
i += 1
# 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
# 九九乘法表
i = 1
while i <= 9:
j = 1
while j <= i:
print("%d*%d=%d" % (j, i, j * i), end="\t") # \t：tab键，解决对齐问题
j += 1
print("")
i += 1
"""
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
"""
函数（基础）
函数（function）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
-------------注意：必须定义在前，调用在后-------------
格式一
定义
def 函数名():
函数体
...
调用
函数名()
案例
def say():
print("hello python")
say() # hello python
say() # hello python
文档注释
文档注释可以为函数添加功能说明，方便开发者查阅函数相关信息
def say():
"""打印 hello python"""
print("hello python")
格式二（参数）
定义
def 函数名(参数列表):
函数体
...
调用
函数名(参数)
案例一
def say(s):
"""打印 指定字符串"""
print(s)
say("hello python") # hello python
def add(a, b):
"""打印 指定两个数字的和"""
print(a + b)
add(2, 3) # 5
形参与实参
形参是函数定义时规定的参数，仅在函数体内有效
实参是函数调用时使用的参数，该值将传递给函数
def 函数名(形参): 参数：形式参数
函数体
...
函数名(实参) 参数：实际参数
调用函数时，实参的数量必须与形参的数量一一对应，否则将报错
案例（打印最大值）
def max2(a, b):
if a > b:
print(a)
else:
print(b)
max2(6, 8)
变量的作用域
局部变量：函数内部定义的变量从定义位置开始到函数定义结束位置有效；
全局变量：函数外部定义的变量在整个文件中有效；
函数间不能共享内部定义的变量；
函数内可以使用全局变量；
如果局部变量与全局变量冲突，通过 global 关键字可以提升局部变量为全局变量，先声明再使用。
def test():
a = 10
print(a)
a = 20
test() # 10
print(a) # 20
global 关键字案例
def test():
global a
a = 10
print(a)
a = 20
test() # 10
print(a)
格式三（返回值）
定义
def 函数名(a, b):
函数体
...
return 函数运行结果返回值
...
调用
变量名 = 函数名(参数列表)
案例
def add(a, b):
return a + b
def div(a, b):
return a / b
a = 2000
b = 1000
c = add(a, b)
print(c) # 3000
print(div(c, 2)) # 1500.0
函数的返回值
使用变量接收不存在返回值的函数，结果为None；
def add(a, b):
"""打印 指定两个数字的和"""
print(a + b)
c = add(2, 3) # 5
print(c) # None
同一个函数执行过程中只能执行一次return语句，执行return语句后，return后面的内容将不再执行，函数执行完毕；
def test1():
return 3
print("--------")
return 5
print(test1()) # 3
同一个函数可以返回多个返回值，使用对应数量的变量接收即可。
def test1():
return 1, 2, 3
print(test1()) # (1, 2, 3)
a, b, c = test1()
print(a) # 1
print(b) # 2
print(c) # 3
函数间调用
在一个函数中调用另一个函数的过程称为函数间调用
def add(a, b):
return a + b
def div(a, b):
c = add(a, b)
return c / 2
print(div(3, 2)) # 2.5
案例（求三个数的最大值）
def max3(a, b):
if a > b:
return a
else:
return b
def test2(a, b, c):
d = max3(a, b)
return max(c, d)
print(test2(5, 2, 8)) # 8
