Python基础手册

编译型语言：程序在执行之前需要⼀个专门的编译过程，把程序编译成为机器语言的文件（可执行文件），运行时不需要重新翻译，直接执行就行了。
解释型语言：编写的程序以文本方式先存储程序代码，最后将代码⼀句⼀句的直接运行。在发布程序时，看起来省了道编译工序，但是每次运行程序的时候，必须先解释成机器语言，然后再运行。

解释型的开发语言代表有：Python，Java等。他们的好处是跨平台（根据软件质量特性就是可移植性），牺牲的是速度，但对于用户来说是在接受范围内。

1.1.4. 第一个Python程序

Python源程序介绍：

Python源程序就是⼀个特殊格式的文本文件，可用任意文本编辑软件进行开发。我们这里使用Pycharm软件开发。
Python 程序的文件扩展名通常都是：.py

实现步骤：

使用PyCharm刚才新创建项目，新建 hello.py文件。新建py文件的方法：右击项目名称 --》New --》Python File

2.输入：hello，点击【Python file】

3.双击新建的hello.py文件，在pycharm编辑器打开，输入代码：

print("hello world!")
print("hello python!")

4.在终端命令行，输入命令：python hello.py，执行python程序

5.或者通过Pycharm运行python程序：在编辑区域，鼠标右击 --> Run ....

print()函数主要作用是用于调试程序代码，结果输出到屏幕上。

1.1.5 程序BUG的产生

关于程序中的缺陷（Bug）：

编写的程序不能正常执行，或者执行的结果不是我们期望的俗称 BUG ，常见错误的原因包括：

手误，比如我们把print()写成rpint()
开发技术能力不足
业务知识理解不足

1.1.6 Python常见错误

认识Python错误和解决错误的方法，比如我们第1个Python程序，常见错误有：

手误，如使用 pirnt("Hello world")，运行代码，将提示：

NameError: name 'pirnt' is not defined（名称错误：'pirnt' 名字没有定义）

缩进错误，比如我们的第1个Python程序，第二行增加一个空格

运行代码，将提示：

IndentationError: unexpected indent （缩进错误：不期望出现的缩进）

遇见Python错误不要慌，比如上面的问题，提示已告诉你问题原因，只需按这提示去解决即可。

1.1.7 Python注释

单行注释：

以 # 开头， # 右边的所有东⻄都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用。

多行注释：

如果希望编写的注释信息很多，一行⽆法显示，就可以使用多行注释。用一对连续的三个引号(单引号和双引号都可以)，把注释内容包起来。

什么时候需要用到注释？

对于复杂的操作，应该在操作开始前写上若干行注释
对于不是一目了然的代码，应在其行尾添加注释

1.2 Python算数运算符与变量概念

1.2.1 Python算数运算符

算数运算符概念：

算数运算符是运算符的一种，是完成基本算术运算的符号。

算术运算的符号：

%	取余数	返回除法的余数9 % 2 = 1
*	乘	10 * 20 = 200
**	幂	又称次方、乘方，2 ** 3 = 8
+	加	10 + 20 = 30
-	减	10 - 20 = -10
/	除	10 / 20 = 0.5
//	取整数	返回除法的整数部分（商） 9 //2 输出结果4

Python 中"*"运算符还可以用于字符串的运算，计算结果就是字符串重复指定次数的结果。

算术运算符的优先级（由⾼到低排序）：

**	幂运算（优先级最高）
*、/、%、//	乘、除、取余数、取整除
+、-	加、减

Python代码进行数学计算时，与数学中的运算符的优先级一致，同样也是先乘除后加减，同级运算符是从左至右计算。

比如：100/2**2，这个等同于100/(2**2)
运算符使用过程中，建议使用()调整计算的优先级，层次清晰，一目了然。

运算符应用场景：

主要对数字的算数运算，比如：在代码里通常会用到计数器，这个就应用到了算数运算。

运算符的使用：

在windows命令行，输入命令：python，进入python解释器。

输入后回车：80+2*5**2
输入后回车：(2+3)*4
输入后回车：print('hello' * 2)

1.2.2 Python变量概念与应用

变量是什么？

变量是内存中存储数据的一个小空间。也就是说需要分配内存空间来存放。
变量由两部分组成：一个是变量名，可以认为是一个标记，或者说是一个别名，主要是用来指向存放数据的位置；另一个是变量值，主要是存放具体的数据内容。

在 Python中，每个变量在使用前都必须赋值，变量赋值以后，该变量才会被创建。

变量如何用？（定义和赋值）

变量的定义赋值方式：变量名 = 值

- 等号（=），是用来标识给变量赋值
- 等号（=），左边的是定义的变量名
- 等号（=），右边的是存储的数据值，然后赋值给左边的变量名。

比如：n1 = 100，n1就是定义的变量名，并没有具体的数据，但知道存放数据的位置；'='号就是赋值，100是数据，通过'='号把100数据赋值给n1变量名。这样找到n1变量名，也就找到100数据

变量的应用场景：

python的变量应用场景广泛，如程序的设计，功能的实现，测试自动化的应用等。所以学好python，从学好变量开始。

变量的基本使用（1.2.2变量.py)：

'''
1.python中字符串用一对单引号或者一对双引号引起来
2.python中数字不需要引号，可直接输入
3.使用print()函数，将变量打印输出到屏幕，用于调试分析
'''

# 1.简单赋值：Variable(变量名)=Value(变量值)
city = "深圳"
print(city)
# 2.多变量赋值Variable1,variable2,...=Value1,Value2,..（多变量赋值也可用于变量交换)
username,password = 'user123',123456
print(username,password)
# 3.多目标赋值，a=b=value
a=b=90
print(a,b)
print(id(a),id(b))
# 4.变量重新赋值
b=100
print(a,b)
# 查看当前定义的变量名
print(dir())

变量名的命名规则：

我们已会定义变量名和使用变量，那么变量名的命名可以随意取吗，就像我们的姓名。答案是否定的，变量名的取名既要有意义又要讲规则。规则如下：

由数字，字母，下划线组成
数字不能开头
不能是括号以及各种特殊符号
不能使用关键字
区分大小写，如：变量名Andy 不等于变量名andy

变量名的命名不能用关键字，那什么是关键字？

关键字，是Python自带的，每一个键字都具有特殊的功能和含义，是我们学习python的渠道。
不能用于变量，不允许定义同关键字相同的变量名，如通过代码查看 Python 中的关键字

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

变量名的命名约定：

约定不是规则，规则是从python语言角度考虑，更好的协调运行代码，必须遵守；约定是从人的角度考虑，更好的识别其含义，是人的一种约定，可遵守可不遵守。

变量名需要由两个或多个单词组成时，可以按照以下方式命名：

每个单词都使用小写字母，然后单词与单词之间使用 _ 下划线连接。如：first_name
小驼峰式命名：第一个单词以小写字母开始，后续单词的首字母大写。如：firstName
大驼峰式命名：每一个单词的首字母都采用大写字母。如：FirstName

1.3 Python数据类型与输入输出

1.3.1 Python数据类型划分

什么是数据类型？

存储数据的一种结构方式，就像我们测试用例按等价类划分概念一样，如数字类型，字符串类型。

Python数据类型按大类分：数字型和非数字型及None类型。

数字型可分为：

整型 ( int ) ：整数数据，如a=100
浮点型（ float ）：带小数点的数据，如a=99.99
布尔型（ bool ）
- 真 True 非0的数 —— 非零即真：如通常1表示真，True也可以表示真
- 假 False 0 ------ 零即假：如通常0表示假，False也可以表示假

非数字型可分为：

字符串 (str)：我们正常输入的一串字符，使用引号表示，如a="这是字符串"
列表(list)：1组数据，用中括号定义[]，多个数据用逗号分隔，数据可修改，如a=[100,99.9,"这是字符串"]
元组(tuple)： 1组数据，用括号定义()，多个数据用逗号分隔，但数据不可修改，如a=([100,99.9],"这是字符串")
集合(set)：1组数据，用在括号定义{}，多个数据逗号分隔，数据不可重复，如a={100,9,"这是字符串"}
字典 (dictionary)：有结构的数据，如 a = {'name':'袁老',"age":100}

None：

None 表示待定类型，或者说不确定具体类型。如：a = None

1.3.2 Python不同数据类型的运算

数字型变量的运算：

两个数字型变量可以直接进行算数运算。
示例代码：1.3.2-1数字型变量运算.py

'''
定义整数 i = 100
定义浮点数 f = 99.99
定义布尔型 b = True
使用上述三个变量相互进行算术运算
'''
i = 100
f = 99.99
b = True

非数字型（字符串）变量的运算：

使用 “+” 拼接字符串，生成新的字符串。比如（1.3.2-2字符串变量加号拼接.py）
first_name = "袁"
last_name = "老"
print(first_name + last_name)
使用 “*” 重复拼接相同的字符串。比如（1.3.2-3字符串变量星号重复拼接.py）
first_name = "袁"
print(first_name*3)

数字型变量与字符串，不能进行运算，如果强行运算会发生什么？

示例代码：1.3.2-4数字型变量与字符串强行运算.py
first_name = "袁"
f = 99.99
i = 100
print(first_name+f+i)
运行代码将报错：TypeError: can only concatenate str (not "float") to str

不同类型变量的转换：

1、将数字类型转换为字符串类型。语法：str(数字）

示例代码：1.3.2-5数字类型转换为字符串类型.py

a = 100
str(a) #把数字型变量a 转化为字符串型
print(type(a))

2、将字符串类型转换为整型。语法：int(字符串)--这个字符串必需是数字的字符串，否则会报错。

示例代码：1.3.2-6字符串转换为数字类型.py

a = "100"
int(a) # 字符串类型a 转化为 int数字类型
b = '我不是数字'
int(b)

3、将字符串类型转换为浮点型。语法：float(字符串)--同样字符串必需是浮点数字的字符串，否则会报错

示例代码：1.3.2-7字符串转换为浮点类型.py

f = "99.99"
float(f) # 字符串类型f 转化为 float数字类型

1.3.3 Python变量通过键盘输入和格式化输出

变量值通过键盘输入：

我们之前使用的变量值都是在程序代码中写死，在程序运行过程中怎样获取到用户在键盘上的输入信息，然后动态的赋值给变量，这就需要用到 input 函数。

语法：变量名 = input("提示信息：")

示例代码：1.3.3-1通过键盘输入数据.py

# 通过 input()函数输入数据，然后赋值给变量name
name = input("请输入姓名：")
# 通过 print()函数把变量name的值打印在显示器上
print(name)
#显示用户输入内容的数据类型
print(type(name))

num1 = int(input("请输入数字："))
print(100+num1)

键盘输入的任何内容，Python 都认为是一个字符串。
如果用户输入的是数字，可以通过int类型转换函数，将字符串类型转化为数字，然后再参与运算。如：int(input("请输入数字："))

变量值通过格式化输出：

什么是格式化输出：

指通过print函数，将自定义的文字信息和变量值一起输出到控制台。

格式化输出的实现方式：

使用格式化操作符（%），包含" % "的字符串，都被称为格式化字符串。

格式化字符都有哪些？

%s：表示字符串。
%d：表示有符号的十进制整数，%06d 表示输出 6 位整数，不足用 0 补全。
%f：浮点数，%.2f 表示只显示小数点后两位.
%%：输出%

怎么使用格式化字符输出？

语法格式：print("格式化字符1，格式化字符2，..." % (变量1, 变量2...))

示例代码：1.3.3-2格式化字符输出.py

stu_name = 'lisa'
course_name = '地理'
score = 99.9
show = '*'*20
print("%s\n学生姓名：%s\n课程名称：%s\n成绩：%.2f\n%s"%(show,stu_name,course_name,score,show))
# print(show +'\n' + "学生姓名："+ stu_name +'\n' +"课程名称："+course_name+'\n'+"成绩:"+str(score))

1.3.4 Python字符串中的转义字符

什么是转义字符？

以‘\’反斜杠字符为开头，后面接上字符，其意思是将反斜杠‘\’和后面的字符转变成为另外的意义。

转义字符有哪些？

\\：反斜杠符号，转变成为另外的意义，为\
\'：单引号，如'
\"：双引号，如"
\n：换行符号
\t：横向制表符号

案例分析：

1、比如print()函数默认结尾是回车。示例代码：1.3.4-1验证print函数默认结尾.py

# 第一行输出完成后，进行了换行，print()函数默认是换行
print("hello python")
print("hello world", end="\n")
print("hello java")

2、把多个 print()函数的输出结果，打印到一行。示例代码：1.3.4-2多个print函数打印一行.py

# 第一行输出完成结束后，不会换行，因为结束符号为空格，不是换行符\n
print("hello world", end=" ")
print("hello python")

如何禁用转义字符串

如果需要字符串输出”\n”或者”\t”，而不是要转义，那么就需要在字符串前面加 r。

比如：print(r"hello\tworld\nhello\\world")

1.4 Python列表与元组数据类型

1.4.1 Python列表[]

概念：List （列表）是 Python 中使用最频繁的数据类型，主要用于存储一串数据信息。在其他语言通常叫做数组。有以下特点：

列表用 [] 定义，列表中的数据之间使用逗号',' 分隔；
列表的索引从 0 开始；
索引就是数据在列表中的位置编号，索引⼜可以被称为下标；

列表定义：变量名 = []

注意：从列表中取值时，如果超出索引范围程序会报错。

# 定义一个空列表变量，名字叫 a
a = []
# 定义一个列表变量，名字叫 list1，有四个元素
list1 = ["深圳","广州","上海","北京"]
# 显示列表第一个元素的值
print(list1[0])
# IndexError: list index out of range
# 错误，列表没有[4]这个值
print(list1[4])

查看列表对象，都有哪些方法：通过dir(列表名)函数

list1 = ["深圳","广州","上海","北京"]
print(dir(list1))

# ['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

列表常用方法:

功能	方法	说明
增加	列表名.insert(索引,数据)	在指定位置插入数据
	列表名.append(数据)	在末尾追加数据
	列表名.extend(另一个列表)	追加另一个列表的值
修改	列表[索引] = 值	修改指定索引的数据
删除	del(列表[索引])	删除指定索引的数据
	列表名.remove(数据)	删除第一次出现的指定数据
	列表名.pop()	删除末尾数据
	列表名.pop(索引)	删除指定索引数据
	列表名.clear()	清空列表
统计	列表名.count(数据)	返回指定数据在列表中出现的次数
	列表名.index(数据)	返回数据在列表中的索引值，如果找不到抛出异常
排序	列表名.sort()	升序排序
	列表名.sort(reverse=True)	降序排序
	列表名.reverse()	逆置，反转

Python列表、集合、字典、字符串变量的公共方法

功能	使用方法	说明
成员运算符	值 in 列表	判断值是否在列表中，存在返回 True，不存在返回 False
统计	len(列表)	返回列表元素个数
	max(列表)	返回列表中最大的数
	min(列表)	返回列表中最小的数据
判断	值 not in 列表	判断值是否在列表中，存在返回 False，不存在返回 True

Python列表拆包概念：就是把一个列表中每个值拆出来，然后赋值给相应的变量。拆包操作同样适用于元组，集合和字典。

# 定义一个列表
list1 = ["深圳","广州","上海","北京"]
# 通过对列表进行拆包方式获取列表中每个元素的值
a, b, c,d = list1
print(a, b, c,d)

示例代码：1.4.1-1列表常用方法.py

1.4.2 Python元组()

概念：Tuple （元组）与列表类似，不同之处在于元组的元素不能修改。

元组定义：变量名 = ()

# 定义一个元组，名字叫 tuple1，有三个元素
tuple1 = ("lisa", 28, 1.75)
# 定义一个空元组，名字叫 tuple2
tuple2 = ()
# 元组只有一个元素时，元素后面需要添加逗号
tuple3 = ("深圳",)
print(tuple3)

元组常用方法：

元组的常用方法与列表类似，元组的内容不可修改，所以没有增加、修改和删除，排序等相关方法。但可以有统计相关方法，如：

元组变量名.count(数据)：返回指定的数据在元组中出现的次数。
元组变量名.index(数据）：返回指定数据在元组中的索引值，如不存在则报异常。

tuple1 = ("lisa", 28,28,'timmy')
print(tuple1.count(28))
print(tuple1.index('timmy'))

元组和列表之间的转换：

把列表转化为元组目的是让列表不可以被修改，以保护数据安全；
使用 list() 函数可以把元组转换成列表；
使用 tuple() 函数可以把列表转换成元组

list1 = ["深圳","广州","上海","北京"]
# 通过 tuple 函数把 list1 转换为元组
tuple1 = tuple(list1)
tuple2 = ("福田","罗湖","光明")
# 通过 list 函数把 tuple2 转换为列表
list2 = list(tuple2)

1.4.3 Python 多维列表

二维列表概念：列表中的数据又是另一个列表。如下列表结构

张三	24
李四	28

用列表存放二维表格

# 定义一个二维列表
list1 = [['张三', 24],['李四', 28]]
# list1[0][0]代表第一行第一列的值
# list1[1][1]代表第二行第二列的值

1.5 Python集合、字典、字符串数据类型

1.5.1 Python集合set()

集合概念：由一组无序排列且不重复的数据组成

创建空集合变量名 = set()

# 定义一个空集合 set1
set1 = set()
print(type(set1))

创建非空集合

# 定义一个非空集合 set1

set1 = {"李飞", 28, 1.75}
# 添加重复的值：李飞，将添加不进去，但程序不会报错
set1.add("李飞")
print(set1)

集合和列表的区别：

列表是有序的对象集合；
集合是无序的对象集合；
同一个集合内值不允许重复

集合常用操作

增加	集合.add(值)	增加值
删除	集合.pop()	删除最后一个值
	集合.remove(值)	删除指定值
	集合.clear()	清空集合

示例代码：1.5.1-1集合的使用与列表区别.py

1.5.2 Python字典{}

概念：

dictionary（字典）通常用于存储“键:值”对的数据，键与值之间用冒号分隔。
- 键(key)是索引，同一个字典内，键名不能重复；
- 值(value)是数据；
字典用{}定义
- 创建空字典：变量名 = {}

# 定义一个字典变量dict1，包含三个键值对
dict1 = {"name":"李飞", "age":22, "height":1.75}

字典与集合的区别：

集合中只有值；
字典是包含键与值的键值对

字典常用操作

增加/修改	字典[“键”] = 值	如果键存在，代表修改已有键的值如果键不存在，代表新增键值对
删除	字典.pop(“键”)	删除指定键
	字典.clear()	清空字典
得到值	字典[“键”]	返回指定键的值

示例代码：1.5.2-1字典的定义与常用操作.py

1.5.3 Python字符串str

概念：字符串就是一串字符集，是编程语言的一种数据类型。可以使用一对双引号 " "或者一对单引号 '' 定义。

在实际开发过程中，如果字符串内部需要使用双引号 " ，可以使用单引号 ' 定义字符串。如果字符串内部需要使用单引号 ' ，可以使用双引号 "定义字符串。

字符串使用双引号定义：str1 = "这是双引号定义的字符串，'里面有单引号'。"
字符串使用单引号定义：str2 = '这里单引号定义的字符串，"里面有双引号"。'

使用（字符串变量[索引 ]）获取一个字符串中指定位置的字符，索引计数从 0 开始。

字符串的常用方法：比如str1.lstrip()

功能	方法	说明
去除空格	字符串.lstrip()	去除左侧空格
去除空格	字符串.rstrip()	去除右侧空格
去除空格	字符串.strip()	去除左右两侧空格
大小写转换	字符串.upper()	将小写字母转化为大写
大小写转换	字符串.lower()	将大写字母转化为小写
拆分	字符串.split()	根据子串拆分字符串，返回由拆分后字符串组成的 list
查找	字符串.find(“字符串”)	查找字符串在字符串中出现的位置，找不到返回 -1
查找	字符串.字符串[索引]	得到指定索引位置的字符
查找	字符串.count(“字符串”)	返回字符串在字符串中出现的次数
判断	字符串.isalpha()	判断字符串是否为字母构成
判断	字符串.isdigit()	判断字符串是否为数字构成
判断	字符串.islower()	判断字符串中所有字母是否都为小写
判断	字符串.isupper()	判断字符串中所有字母是否都为大写
替换	字符串.replace(“字符串”, ”新字符串”)	查找字符串，并用新的字符串替代
替换	字符串.swapcase()	将大小写字母反转

示例代码：1.5.3-1字符串的定义与常用操作.py

1.6 Python字符串切片与分支概念

1.6.1 Python字符串切片

切片概念：使用索引值来限定范围，从一个大的字符串中切出小的字符串。

切片语法：字符串[开始索引:结束索引:步长]

[开始索引, 结束索引，]指定的区间属于左闭右开型（不包含结束位本身）
开始索引数字可以省略，冒号不能省略
结束索引数字可以省略，冒号不能省略
步长默认为 1 ，如果连续切片，数字和冒号都可以省略

索引的顺序：顺序索引就是从左向右计算索引

截取从 2~ 5 位置的字符串

str1 = "我爱python自动化测试！"
s = str1[2:5]
print(s)

截取从 2 ~ 末尾的字符串

str1 = "我爱python自动化测试！"
s = str1[2:]
print(s)

截取从开始 ~ 5 位置的字符串

str1 = "我爱python自动化测试！"
s = str1[:5]
print(s)

截取完整的字符串

str1 = "我爱python自动化测试！"
s = str1[:]
print(s)

从开始位置，每隔一个字符截取字符串

str1 = "我爱python自动化测试！"
s = str1[::2]
print(s)

索引的倒序：倒序索引就是从右向左计算索引

截取字符串末尾5个字符

str1 = "我爱python自动化测试！"
s = str1[-5:]
print(s)

开始索引（-5）即倒过来数，-1是"!"，-5则是"动"

使用切片，使字符串的逆序

str1 = "我爱python自动化测试！"
s = str1[::-1]
print(s)

开始索引和结束索引不填，表示获取所有字符串，步长为-1,表示从-1位置的字符开始反向截取

示例代码：1.6.1-1字符串切片.py

1.6.2 Python分支概念

分支概念：分支在我们的生活中比比皆是，比如我们坐地铁，需要48小时核酸码，保安对我们的码颜色判断是否可以进入。

程序中分支应用（伪代码）：

if 48小时核酸码:

if 有绿码:

不容易啊，进站坐地铁去！

else:

噢,no！不可以进站！

else:

噢,no！不可以进站！

程序中用到的比较运算符：

==	比较运算符左边的值是否等于右边的值，如果是，则条件成立，返回True，如果不是，则条件不成立，返回False
!=	比较运算符左边的值是否不等于右边的值，如果是，则条件成立，返回True
>	比较运算符左边的值是否大于右边的值，如果是，则条件成立，返回True
<	比较运算符左边的值是否小于右边的值，如果是，则条件成立，返回True
>=	比较运算符左边的值是否大于或等于右边的值，如果是，则条件成立，返回True
<=	比较运算符左边的值是否小于或等于右边的值，如果是，则条件成立，返回True

程序中用到的逻辑运算符：

and

x and y

x和y，两个比较运算结果值都为True时，才返回True;

x和y，只要有一个比较运算结果值为False时，就返回False

x or y

x或者y，只要有一个比较运算结果值是True时，就返回True;

x或者y，两个比较运算结果值为False时，就返回False

not

not x

x 比较运算结果值是True时，则返回False;

x 比较运算结果值是False时，则返回True

赋值运算符总结：

=	仅赋值运算符，
+=	加法赋值运算符，例子： s += n → s = s + n
-=	减法赋值运算符，例子： s -= n → s = s - n
*=	乘法赋值运算符，例子： s = n → s = s n
/=	除法赋值运算符，例子： s /= n → s = s / n
//=	取整除赋值运算符，例子： s //= n → s = s // n
%=	取余数赋值运算符，例子： s %= n → s = s % n
**=	幂赋值运算符，例子： s = n → s = s n

示例代码：1.6.2-1赋值运算符总结.py

1.7 Python分支结构

1.7.1 单分支结构

语法格式如下：满足条件，则做

if 判断的条件:

如果条件判断成立，则做这些事情
.......

if分支结构的代码行缩进为一个 tab 键，或者 4 个空格 —— 建议使用空格。
对于整个if语句，可看成一个完整的代码块

pass 占位符：当 if 语句内容为空的时候，可使用 pass 占位符，避免程序报错，后续再完善代码。

if 要判断的条件:

pass

示例代码：1.7.1-1单分支判断核酸码问题.py，需求如下：

定义一个变量code记录核酸码，使用input输入"绿码" 或"黄码" 或"红码"，
判断是否"绿码"，如果不是"绿码"，则不充许进地铁

# 通过input接收键输入的内容，赋值给变量code
code = input('请输入你的核酸码:')
# 判断是否绿码
# 一个完整的语句块，以下是语句块的开始
if code == '绿码':
print('允许进入地铁')
# 一个完整的语句块，以上是语句块的结束

print("单分支语句块执行完成后，执行后续的代码")

if 语句以及缩进部分是一个完整的代码块

1.7.2 双分支结构

语法格式如下：满足条件时要做，不满足条件时也要做

if 要判断的条件:

条件判断成立时，要去做的事情

else:

条件判断不成立时，也要去做的事情

if 和 else 语句与各自的缩进部分，共同组成一个完整的代码块

示例代码：1.7.2-1双分支判断核酸码问题.py，增加需求如下：

增加条件不成立时也要去做的需求，如果条件不成立，则显示：不是绿码，去做核酸，绿码后再来！

code = input('请输入你的核酸码:')
# 判断是否绿码
# 一个完整的语句块，以下是语句块的开始
if code == '绿码':
print('允许进入地铁')
else:
print("不是绿码，去做核酸，绿码后再来！")
# 一个完整的语句块，以上是语句块的结束

print("双分支语句块执行完成后，执行后续的代码")

1.7.3 多分支结构

语法格式如下：存在多个分支条件判断，根据不同条件判断，执行不同条件成立的代码

if 条件1:

条件1 成立时，要做的事情

elif 条件2:

条件2 成立时，要做的事情

elif 条件3:

条件3 成立时，要做的事情

else:

所有条件不成立时，要做的事情

示例代码：1.7.3-1多分支判断核酸码问题.py，增加需求如下：

增加条件判断，如果是黄码，则显示：不是绿码，去做核酸
增加条件判断，如果是红码，则显示：OMG，马上去小屋隔离观察
如果所有条件不成立，则显示：你的核酸码错了！

code = input('请输入你的核酸码:')
# 一个完整的语句块，以下是语句块的开始
if code == '绿码':
print('允许进入地铁')
elif code == '黄码':
print("不是绿码，去做核酸，绿码后再来！")
elif code == '红码':
print("OMG，马上去小屋隔离观察！")
else:
print("你的核酸码错了！")
# 一个完整的语句块，以上是语句块的结束

print("多分支语句块执行完成后，执行后续的代码")

1.7.4 嵌套分支结构

语法格式如下：在满足外层条件的前提下，再增加内层的子级条件判断

if 外层条件判断:

外层条件满足执行的代码
……

if 内层条件判断:

内层条件判断满足时，执行的代码
……

else:

内层条件判断不满足时, 执行的代码

else:

外层条件判断不满足时，执行的代码

if ...else... 为一个语句块，在语句块中，可以嵌套另一个if...else...

示例代码：1.7.4-1嵌套分支判断核酸码问题.py，需求如下：

外层条件判断需要48小时核酸，内层条件判断需要绿码，满足内层条件方可进去坐地铁。
不满足条件，则不可以进入坐地铁

time = int(input('请输入核酸码时间24/48/72:'))
# 一个完整的语句块，以下是语句块的开始
if time <= 48:
print('执行外层条件满足执行的代码')
code = input('请输入你的核酸码:')
# 内层语句块，以下是语句块的开始
if code == '绿码':
print('允许进入地铁')
else:
print("不是绿码，去做核酸，绿码后再来！")
# 内层语句块，以上是语句块的结束
else:
print("不是48小时核酸，去做核酸")
# 一个完整的语句块，以上是语句块的结束

print("双分支语句块执行完成后，执行后续的代码")

1.7.5 使用逻辑运算符的分支结构

概念：Python中的逻辑运算符包括：and 与／or 或／not 非三种。

and（与）：条件 1 and 条件 2

两个条件同时满足，返回 True
只要有一个不满足，就返回 False

# 需求：健康码为“绿码”，且是48小时内核酸，才能能行
code = '绿码'
time = 48
if code == '绿码' and time <= 48:
print('正常通行')
else:
print('不能通行')

or（或）：条件 1 or 条件 2

两个条件只要有一个满足，返回 True
两个条件都不满足，返回 False

# 需求：健康码为绿码，或者是义工，才能能行
code = '绿码'
tag = '义工'
if code == '绿码' or tag== '义工':
print('正常通行')
else:
print('不能通行')

not（非）：not 条件

条件为真，返回False；条件为假，返回True

# 需求：健康码不是黄码和红码，才能能行

code = '绿码'
if not code == '绿码':
print('不能通行')
else:
print('正常通行')

示例代码：1.7.5-1逻辑判断核酸码问题.py

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)