Python10

课程：B站大学-霍格沃兹
记录python学习，直到学会基本的爬虫，使用python搭建接口自动化测试就算学会了，在进阶webui自动化，app自动化

---

# python常用快捷键

快捷键	作用
Tab键	跳制表域
Ctrl + /	代码注释
Ctrl + F	查找
Ctrl + R	替换
Alt + Enter	问题修复
Ctrl + Alt + L	代码格式化
Ctrl + D	复制当前光标所在行代码
Ctrl(Alt) + Shift + 上下方向键	上下移动光标所在行代码
Ctrl + G	跳转到指定行：列

python编码规范性

提高代码的可读性并使其在各种 Python 代码中保持一致很重要。总结一句话就是 可读性很重要。
Python 官方完整

缩进

在 Python 中，缩进是一种非常重要的语法规则，Python 使用缩进来确定代码的层次结构和执行顺序。

• 建议使用Tab键实现缩进
• 同一级别的代码块的缩进量必须相同

class Student(object):def __init__(self, name, age):self.name = nameself.age = agedef info(self):print(f"Name: {self.name}")if self.age >= 18:print("已成年")else:print("未成年")

注释

注释，是指在代码中对代码功能进行解释的描述性文字，可以提高代码的可读性。注释的内容将被 Python 解释器忽略，并不会在执行结果中体现出来。
Python 中，提供 3 种类型的注释:

• 单行注释
  在 Python 中，使用#作为单行注释的符号。注释从符号#开始直到换行为止，其后面所有的内容都作为注释的内容而被 Python 解释器忽略。

# 我是一段注释

• 多行注释

在 Python 中，并没有一个单独的多行注释标记，而是将注释内容包含在一对三引号之间，这样的代码将被解释器忽略。由于这样的代码可以分为多行编写，所以也可以作为多行注释。

'''
可以使用
三单引号
实现
多行
注释
'''"""
可以使用
三双引号
实现
多行
注释
"""

• 文档注释
  文档注释实际是多行注释的一种特殊使用形式，为 Python 文件、模块、类或者函数等添加版权、功能,说明等信息，例如，下面的代码将使用多行注释为程序添加功能、开发者、版权、开发日期等信息，也经常用来解释代码中重要的函数、参数等信息，利于后续开发者维护代码

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print"""print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)Prints the values to a stream, or to sys.stdout by default.Optional keyword arguments:file:  a file-like object (stream); defaults to the current sys.stdout.sep:   string inserted between values, default a space.end:   string appended after the last value, default a newline.flush: whether to forcibly flush the stream."""pass

命名规范

命名规范在编写代码中起到了很重要的作用，通过使用有意义的命名，可以传达变量、函数和类的用途和含义，使其他人（包括自己）更容易理解代码的意图，避免错误的变量赋值或函数调用。并且当多人合作开发或维护代码时，一致的命名约定使团队成员能够更轻松地理解和修改彼此的代码。
具体包括：

• 包名尽量短小，全小写字母，不推荐使用下划线
• 模块名尽量短小，全小写字母，可以使用下划线分隔多个字母
• 类名采用单词首字母大写形式，即 Pascal 风格。
• 常量命名时全部采用大写字母，可以使用下划线
• 变量、函数名也是全小写字母，多个字母间用下划线_进行分隔
• 使用单下划线_开头的模块变量或者函数是受保护的
• 使用双下划线__开头的实例变量或方法是类私有的

输入和输出

输入和输出

在编写程序时，输入和输出是非常重要的功能。输入和输出用来获取和显示程序运行所需的数据和程序运行时的信息或结果。

输入函数

在 Python 中，使用 input() 函数从键盘获取输入的数据。输入的任何数据，都以字符串形式保存到程序中。

name = input()
print("您好，" + name + "！")

当程序运行到 input() 函数时，程序进入到阻塞状态，等待输入，直至按下回车键。 但是，此时的运行状态并不友好。

input() 函数可以在输入数据之前，输出一些提示信息，让输入界面更加友好。

name = input("请输入您的姓名：")
print("您好，" + name + "！")

输出函数

在 Python 中，可以使用 print() 函数输出文本和变量。

格式：print(values, sep=" ", end="\n")

values: 需要输出的数据
sep=" ": 多个数据之间的分隔符，默认为一个空格
end="\n": 一次输出后的结束符，默认为换行符
基本使用

#输出一个数据
print("Hello World")

# 输出多个数据
print("Hello", "Python", 20, True)

#指定分隔符

在输出多个数据时，如果不想使用默认的空格做为分隔符，可以通过 sep 参数指定分隔符。

print("Hello", "Python", 20, True, sep='---')

指定结束符

print 函数默认一次输出后，都会以换行符结束，下一次输出会重启一个新行输出。
如果在多次输出时，实现在一行输出显示，需要使用 end 参数指定结束符。

print("Hello", end="")
print("World")
print("Python", end="---")
print("Java")

tips:
接受用户键盘输入，提示用户输入用户名，打印对应名户名的欢迎信息。

# first.py
username = input("请输入用户名：")
print(username, "欢迎你～")

username = input("请输入用户名：")：使用 input 函数接受用户输入用户名，然后将其存储在变量 username 中。
print(username, "欢迎你～")：使用 print 函数输入 username 变量与字符串。

函数定义与调用

什么是函数

函数是一段可重复使用的代码块，它执行特定的任务并返回一个结果。
在编程中，函数用于将一段代码逻辑封装起来，以便在需要时可以方便地调用。
函数的主要目的是提高代码的重用性和可维护性。
函数通常由以下几个组成部分构成：

1. 函数名：函数名用于标识函数，以便在代码中调用它时使用。
2. 参数：参数是函数在执行时所需的数据。
3. 函数体：函数体是函数的实际代码逻辑，由若干语句组成。
4. 返回值：返回值是函数体代码执行过后的运行结果。

内置函数

内置函数是指开发语言中预先定义好的实现特定功能的函数，可以直接使用。
比如： 输入函数 input(), 输出函数 print()等

函数定义

虽然系统预先定义好了大量的内置函数，但这些函数，还不能满足实际的开发需求，所以程序中允许根据实际需求自定义函数。
语法格式：

def function_name([parameter_list]): ['''注释信息'''] [function_body]return [result]

说明：

• def: 自定义函数的关键字。

• function_name： 函数名称，在调用函数时使用，命名需要符合标识符命名规则。
  () : 函数的特征，用来书写参数列表。

• parameter_list： 用来接收函数运行时所需的外部数据（此章节不讲解）。

• :：Python 固定语法。

• 注释信息：非必须部分，函数的注释内容，通常是说明该函数的功能、要传递的参数的作用等。

• function_body：函数体，用来实现函数功能的逻辑代码。

• return [result]: 用来结束函数或将函数运行结果返回（此章节不讲解）。

def show(): """此函数用来输出 Hogwarts """print("Hogwarts")

注意：函数定义完成之后直接运行程序，将不显示任何内容。

函数调用

调用函数也就是执行函数。如果把创建函数理解为理解为创建一个具有某种功能的工具，那么调用函数就相当于使用该工具。
语法格式：

function_name([parameters_value])

-function_name：函数名称，要调用的函数名称，必须是已经创建好的（包括内建的和自定义的）。
-parameters_value：参数列表，用来提供函数运行时使用的数据，可省略。
(): 函数的特征，参数列表可省略，但圆括号不能省略。

print("第一次函数调用")
show()
print("第一次函数调用")
show()
print("程序执行结束")

函数返回值

函数返回值是指函数在被调用执行后，经过一系列的代码执行运算，得到一个处理结果，交给函数调用者的结果就是返回值。比如去饭店点菜后，返回的结果就是做好的被点的菜。

函数返回值通过 return 语句实现，一个函数在执行过程中，一旦遇到 return 语句，立刻就会停止执行，返回到函数调用处继续向下执行。

如果一个函数中，没有显示的书写 return 语句，函数实际也有返回值，默认返回值为 None

def get_number():num = input("请输入一个数字：")num = int(num)return num

上面的函数用来从键盘输入一个数字，因为默认键盘所有输入的内容都是以字符串形式加载到程序中，所以需要进行类型转换，将转换后的数字返回给使用者。

如果想使用一个输入的数字时，就可以调用该函数。

print("hello" * get_number())

上面的代码是将字符串 hello 重复拼接 N 次（通过get_number函数从键盘输入的数字）后输出。

在这里只简单介绍函数返回值的使用，后面还会有章节详细讲解函数返回值的使用。

函数参数

函数参数是指在调用函数执行时，给定的一些函数执行过程中需要的数据。比如点外卖时，需要告知吃哪些菜，送到哪里，这些就是外卖在制做和送达时需要的数据。

程序也是一样，很多情况下，函数在执行过挰中，需要调用者给被调函数传入一个数据，才能让函数正确执行。

函数的参数根据不同的场景分为 实际参数 和 形式参数 两种 ：

实际参数: 也称为实参，是在函数调用时需要被传递的数据，可以是任意形式能得到一个具体值的表达式。
形式参数: 也称为形参，是函数在定义在函数参数列表中的变量，用来接收数据，并在函数执行时通过形参使用接收的数据，所以形参只能是变量。

def add(a, b):return a + bprint(add(1, 2))
print(add(3, 4))

上面代码中， add 函数只负责对两个数字进行加法计算，并将结果返回，具体对哪两个数字计算，函数并不知道，也不关心。

在调用 add 函数时，通过实参传递的两个数字会被 add 函数的形参接收，并进行计算。

关于函数的参数，还有很多形式，在这里只介绍简单的使用，后面还会有章节详细讲解函数参数的使用。

注意：

• 程序在执行到函数调用时，会跳转到函数定义位置执行函数体中的代码。

• 函数体执行结束后，将返回到函数调用处继续向后执行其它代码。

• 形式参数是用来接收数据的变量

• 实际参数是执行函数时真正参与计算的数据。
  tips:
  定义函数，完成以下功能：提示用户输入编程语言名称，打印信息 xx是最受欢迎的编程语言！

# first_func.py
def language():lan = input("请输入编程语言名称：")print(lan, "是最受欢迎的编程语言！")
# 调用函数
language()

1. def language():：定义名为 language 的函数。
2. lan = input("请输入编程语言名称：")：函数体，使用 input 函数接受用户输入编程语言名称，然后将其存储在变量 lan
   中。
3. print(lan, "是最受欢迎的编程语言！")：函数体，使用 print 函数输入 lan 变量与字符串。
4. language()：调用函数 language 使其执行。

标识符

什么是标识符

在 Python 中，标识符是用来标识变量、函数、类、模块和其他对象的名称。 需要注意的是，在定义标识符的时候，虽然很自由，但是也不能随心所欲，合法的标识符需要遵从一定的规范。

命名规范

标识符的命名，需要遵从 4 项规范。

1. 见名知意
   一个项目中会存在大量的变量名，函数名，方法名，类名等标识符，所以在对标识符进行命名时，见名知意是第一准则。

例如：get_name、is_select、name、age 等都是符合规则的标识符命名。

切勿在代码中出现大量 a1, a2, a3, b1, b2, b3 的标识符，虽然语法中通过不报错，但在使用时容易混淆。

2. 不能使用关键字
   关键字是 Python 语言中具有特殊含义的单词，例如 if、else、for、def 等等。

3. 标识符由英文字母、下划线 _ 和数字组成，但不能以数字开头
   hogwarts666 是合法的标识符，而 666hogwarts 则是非法的标识符。

4. 区分大小写
   hogwarts 和 Hogwarts 是两个不同的标识符。

hogwarts = 666
Hogwarts = "霍格沃兹"
print(hogwarts)
print(Hogwarts)

正确使用标识符是 Python 编程的基础之一。

通过遵守标识符的命名规范，我们可以编写出更加清晰、易于理解的 Python 代码，同时，我们也可以避免一些常见的编程错误。

因此，在编写 Python 代码时，请务必注意标识符的命名规范。

关键字

什么是关键字

关键字是指在 Python 编程语言中具有特殊含义的保留单词。这些关键字被 Python 解释器用于识别程序的结构和语义，从而执行相应的操作。

在 Python 中，关键字不可以用作变量名、函数名或其他标识符的名称，否则会导致语法错误。

查看关键字

Python 的关键字可能会随着版本的更新而变化，Python3.9 版本共有关键字 36 个， Python3.10 版本的关键字共有 35 个。

可以通过 Python 内置的 keyword 模块，来查看所有的关键字。

# 导入内置关键字模块
import keyword# 打印所有的关键字,每三行打印一次，这些关键很常用意思明确
kw_list = keyword.kwlist
for i in range(0, len(kw_list), 3):print(' '.join(kw_list[i:i+3]))
response：
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 中定义变量非常简单，只需将数据通过等号(=)赋值给一个符合命名规范的标识符即可。

name = "霍格沃兹"

Python 是动态强类型语言，变量无须声明类型即可直接赋值，并且变量保存的数据类型可以随时在使用过程中进行改变，Python 会根据保存数据的不同对变量类型进行动态推导来确定变量的数据类型。Java就需要声明了

name = "霍格沃兹"
name = 123

变量的使用

变量的使用是指在程序中引用一个已经定义的变量。

例如，如果我们想使用之前定义的 name 变量，则可以使用：

print(name)

变量的地址

内置函数 id() 可以获取变量的内存地址，也就是这个变量在计算机内存中的唯一标识，通常是用一串数字表示。

每个变量在内存中都有一个唯一的地址，通过比较两个变量的内存地址，可以判断它们是否是同一个变量。如果两个变量的内存地址相同，那么它们就是同一个变量。

print(id("霍格沃兹"))name = "霍格沃兹"
print(id(name))school = "霍格沃兹"
print(id(school))

显然都是同一个变量，只是变量名不一样，但是存储的内容和内存地址相同

数据类型

数据类型是指定程序在运行过程中，将各种数据根据表示形式和组织形式划分为不同的分类。

例如，一个人的姓名可以用字符类型存储，年龄可以用数值类型存储，而婚否可以用布尔类型存储，这些都是 Python 中的基本数据类型。

标准数据类型
Python3 中标准数据类型有：

基本数据类型
Number（数字）
String（字符串）
bool（布尔类型）
复合数据类型（容器类型）
List（列表）
Tuple（元组）
Dictionary（字典）
Set（集合）
空类型None
Python3 根据数据的特性可分为：

• 不可变数据类型：Number（数字）、bool（布尔类型）、String（字符串）、Tuple（元组）。
• 可变数据类型：List（列表）、Dictionary（字典）、Set（集合）。 类型查看

为了方便检查一个变量的具体类型，可以使用 Python 内置的 type() 函数查看变量的类型。

# 数字类型
num = 666
print(type(num))# 布尔类型
b = True
print(type(b))# 字符串类型
s = "学测试开发升职加薪，就来霍格沃兹测试学社"
print(type(s))# 空类型
x = None
print(type(x))

数字类型

Python 中，数字类型 Number， 包括整数 int、浮点 float 数和复数 complex 三个子类型。

用来表示程序中不同的数字类型的数据。

整数

整数类型：用来表示整数数值，即没有小数部分的数值，在 Python 中，没有 Long 类型，统一使用 int 类型表示。

n = 10
print(n)
print(type(n))
n = 12312312823547082374508273450823754082374508327540837250982375098273540823750482374508235038247503245
print(n)
print(type(n))

浮点数

浮点类型：用来表示带小数点的数值，在 Python 中，没有 Double 类型，统一使用 float 类型表示。

p

i = 3.14
print(pi)
print(type(pi))
pi = 3.141592652346234234346345346345345345345
print(pi)
print(type(pi))
注意float精度为16位

复数

复数类型：一般在数学和物理学中有广泛的应用，例如在电路分析、信号处理和量子力学中，在此了解即可。

n = 4+3j
print(n)
print(type(n))

布尔类型

Python 中的布尔类型 bool 是 整数类型 int 的一个子类，用来描述逻辑关系的正确与否。

布尔类型只有两个值，即 True 和 False 表示真和假，在 Python 中，布尔类型通常用于判断逻辑关系和状态标记。
非0值为true 0为false，这个在条件判断中非常常用，数据库中查找值也很常用

条件判断

x = 5
y = 10
print(x < y)  # 输出True
print(x > y)  # 输出False

状态标记

程序开发过程中，经常需要标记一些状态，比如是否选中，是否点击等，都可以使用记录布尔值的变量记录状态。

isSelect = False
isExist = True

假值状态

在 Python 中，所有的对象都可以判断是否为真。其中，只有下面列出的几种情况得到的值为假，其他对象在 if 或者 while 语句中都表现为真。

常见的假值类型：

• False
• None
• 数值中的零，包括 0、0.0、虚数 0。
• 空序列，包括 空字符串、空元组、空列表、空字典。
  上面这些值都是false，这些在后端和前端交互中非常常见和使用，程序的本质就是玩数据

类型转换

Python 是动态类型的语言(也称为弱类型语言)，不需要像 Java 或者 C 语言一样必须在使 用变量前声明变量的类型。虽然 Python 不需要先声明变量的类型，但有时仍然需要用到类型转换。

自动转换

自动转换也称为隐式类型转换，程序在执行过程中自动完成，将数据精度低转换为数据精度高的类型。

有些时候，在对不同类型的数据进行运算时，Python 会自动将它们转成同样的类型，然后再计算结果。

n = 10 + 3.14
print(n, type(n))

n = False + 1
print(n)
print(type(n))

强制转换

强制转换也称为显式类型转换，需要在代码中使用类型函数来转换。

比如通过 input() 函数获取的数字，实际为一个数字字符串，如果需要进行计算，需要将其转换成真正的数字才能进行数据计算。

如果我们不进行类型转换，那么可能会导致程序出现错误或者无法正常运行。

# 此代码在执行时会报类型错误
title = "霍格沃兹" + 666
print(title, type(title))title = "霍格沃兹" + str(666)
print(title, type(title))

Python 提供了多种类型转换的函数：

int(x)：将 x 转换为整数。

如果 x 是一个字符串，那么它必须是一个表示整数的字符串，否则将会抛出异常。

float(x)：将 x 转换为浮点数。

如果 x 是一个字符串，那么它必须是一个表示浮点数的字符串，否则将会抛出异常。

complex(x)：将 x 转换为复数。

如果 x 是一个字符串，那么它必须是一个表示复数的字符串，否则将会抛出异常。

bool(x)：将 x 转换为布尔值。

如果 x 是一个空对象、0、空字符串、空列表、空元组、空字典 或者 False ，那么将返回 False ，否则将返回 True 。

str(x)：将 x 转换为字符串。

如果 x 是一个对象，那么将会调用该对象的 str() 方法，将其转换为字符串。

chr(x): 将一个整数转换为一个字符。

虽然结果是一个字符，但其本质依然是一个字符串类型。

# 将字符串转换为整数
x = int("123")
print(x)
print(type(x))

# 将字符串转换为浮点数
y = float("3.14")
print(y)
print(type(y))

# 将数字转换为字符串
z = str(123)
print(z)
print(type(z))

# 将数字转换为布尔类型
b = bool(123)
print(b)
print(type(b))

# 将数字转换为字符
c = chr(65)
print(c)
print(type(c))

需要注意的是，如果在强制类型转换时，传递的转换数据不合法导致无法转换，那么将会抛出异常。

x = int("霍格沃兹")

执行后会提示：ValueError: invalid literal for int() with base 10: '霍格沃兹'。

运算符

什么是运算符
运算符是用于进行各种运算操作的符号或关键词。

在数学和计算机编程中，运算符被用来表示不同的运算操作，例如加法、减法、乘法、除法等。

比如:

• 4 + 5，其中，4 和 5 为操作数，+ 为运算- 符。
• a = 10， 其中， a 和 10 为操作数， = 为运算符。
• print(), 其中， print 为操作数， () 为运算符。
  Python 中提供了丰富的运算符，通过这些运算符可以在开过程中实现复杂的逻辑计算。

Python 语言常用运算符如下:

• 算术运算符

• 比较（关系）运算符

• 赋值运算符

• 逻辑运算符

• 成员运算符

• 身份运算符

• 运算符优先级
  这些运算符，根据使用操作数的不同，可分为：

• 单目运算符

• 双目运算符

• 三目运算符
  在每一门语言中，运算符都是非常简单，但是非常重要，非常难以熟练掌握和灵活应用的知识点。

算术运算符

在编写程序时，可以使用算术运算符来进行基本的数学计算。

Python 中的算术运算符包括加法、减法、乘法、除法、取模和幂运算

运算符描述

运算符	描述
+	两个操作数相加
-	两个操作数相减
*	两个操作数相乘
/	两个操作数相除，结果为浮点数类型
%	也称为求余运算符， 两个操作相除，取余数为计算结果
**	返回 x 的 y 次幂
//	两个操作数相除，取商，结果为整数类型
-	两个操作数

加法运算符 +

加法运算符用于将两个数相加。
例如，a + b 表示将 a 和 b 相加的结果。 如果 a 和 b 都是数字，则加法运算符将执行数学加法操作。 如果 a 和 b 是字符串，则加法运算符将执行字符串连接操作。

a = 10
b = 20
c = a + b
print("a + b 的值为：", c)

s1 = "hello"
s2 = "hogwarts"
res = s1 + s2
print("字符串拼接结果为：", res)

减法运算符 -

减法运算符用于将一个数减去另一个数。例如，a - b 表示将 b 从 a 中减去的结果。

a = 10
b = 20
c = a - b
print("a - b 的值为：", c)

乘法运算符 *

乘法运算符用于将两个数相乘。例如，a * b 表示将 a 和 b 相乘的结果。

a = 10
b = 20
c = a * b
print("a * b 的值为：", c)

除法运算符 /

除法运算符用于将一个数除以另一个数。例如，a / b 表示将 a 除以 b 的结果。需要注意的是，如果除数为 0，将会抛出异常。

在Python中，使用 / 进行除法运算时，会得到一个浮点数，如果需要整除运算需要使用 // 整除运算符

a = 10
b = 20
c = b / a
print("b / a 的值为：", c)

取模运算符 %

取模运算符用于获取两个数相除的余数。例如，a % b 表示将 a 除以 b 的余数。

需要注意的是，取模运算本质上也是除法运算，如果除数为 0，将会抛出异常。

a = 10
b = 20
c = b % a
print("b % a 的值为：", c)

幂运算符**

幂运算符用于获取一个数的指数幂。例如，a ** b 表示将 a 的 b 次方。

a = 2
b = 10
c = a ** b
print(“a ** b 的值为：”, c)

整除运算符 //

整除运算符用于将一个数除以另一个数，该运算符会得到一个整数的商。
需要注意的是，如果除数为 0，也将会抛出异常。

a = 10
b = 20
c = b // a
print("b // a 的值为：", c)

赋值运算符

赋值运算符是使用 = 做为运算符号，将运算符右侧的数据或表达式的结果，保存到运算符左侧的标识符中。

在使用赋值运算符时，运算符右侧可以是任意类型的数据，但左侧必须是一个变量，否则会报错。

除普通的赋值运算符外，赋值运算符还可以和算术运算符组合成为复合赋值运算符。

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

普通赋值运算符 =

将等号左侧的数据保存到等号右侧的变量中

a = 1
s = "Hello"
sum = 1 + 2

赋值运算符还支持同时定义多个变量

a, b, c = 1, 2, 3
print(a, b, c)

复合赋值运算符 +=

+= 运算符是算术运算符 + 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行加法计算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a += 20 # 相当于表达式  a = a + 20
print(a)

复合赋值运算符 -=

-= 运算符是算术运算符 - 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行减法计算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a -= 20 # 相当于表达式  a = a - 20
print(a)

复合赋值运算符 *=

*= 运算符是算术运算符 * 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行乘法计算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a *= 20 # 相当于表达式  a = a * 20
print(a)

复合赋值运算符 /=

/= 运算符是算术运算符 / 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行除法计算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a /= 20 # 相当于表达式  a = a / 20
print(a)

复合赋值运算符 //=

//= 运算符是算术运算符 // 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行整除计算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a //= 20 # 相当于表达式  a = a // 20
print(a)

复合赋值运算符 %=

%= 运算符是算术运算符 % 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行取模计算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a %= 20 # 相当于表达式  a = a % 20
print(a)

复合赋值运算符 **=

**= 运算符是算术运算符 ** 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。

表达式会将等号左侧变量中的数据与等号右侧的值进行幂运算，然后将计算结果重新保存到等号左侧的变量中。

a = 10
a **= 20 # 相当于表达式  a = a ** 20
print(a)

复合赋值运算符使用注意

当使用复合赋值运算符时，计算过程上看似对运算符进行展开后运算，而实际执行过程中，复合赋值运算符并不会进行展开操作。

特别是复合赋值运算符和其它运算符一起使用时，要特别注意。

n = 2
# 该表达式结果为 14， 并不是10
# 如果一定要展开，可以理解展开后为 n = n * ( 3 + 4)
n *= 3 + 4
print(n)

关系运算符

关系运算符也称为比较运算符，用来对参与运算的两个操作数进行比较，确认两个操作数之间的关系，运算结果会返回一个布尔值

Python 中提供的关系运算符如下表所示：

运算符	描述
==	等于 ： 比较对象是否相等
!=	不等于 ： 比较两个对象是否不相等
>	大于 ： 返回 x 是否大于 y
<	小于 ： 返回 x 是否小于 y
>=	大于等于 ： 返回 x 是否大于等于 y。
<=	小于等于 ： 返回 x 是否小于等于 y。

等于 ==

== 用来判断两个操作数是否相同，如果相同，结果为真 True，如果不同，结果为假 False。

print( 1 == 2)
print( 1 == 1)
print( 1 == "2")
print( 2 == "2")
print( "abc" == "abc")
print( "abc" == "ABC")

不等于 !=

!= 用来判断两个操作数是否不同，如果不同，结果为真 True，如果相同，结果为假 False。

print( 1 != 2)
print( 1 != 1)
print( 1 != "2")
print( 2 != "2")
print( "abc" != "abc")
print( "abc" != "ABC")

大于 >

> 用来判断左操作数是否大于右操作数，如果大于，结果为真 True，否则，结果为假 False。

print( 1 > 2)
print( 1 > 1)
print( 1 > "2")
print( 2 > "2")
print( "abc" > "abc")
print( "abc" > "ABC")

小于 <

< 用来判断左操作数是否小于右操作数，如果小于，结果为真 True，否则，结果为假 False。

print( 1 < 2)
print( 1 < 1)
print( 1 < "2")
print( 2 < "2")
print( "abc" < "abc")
print( "abc" < "ABC")

大于等于 >=

>= 用来判断左操作数是否大于或等于右操作数，如果大于或等于，结果为真 True，否则，结果为假 False。

print( 1 >= 2)
print( 1 >= 1)
print( 1 >= "2")
print( 2 >= "2")
print( "abc" >= "abc")
print( "abc" >= "ABC")

小于等于 <=

<= 用来判断左操作数是否小于或等于右操作数，如果小于或等于，结果为真 True，否则，结果为假 False。

print( 1 <= 2)
print( 1 <= 1)
print( 1 <= "2")
print( 2 <= "2")
print( "abc" <= "abc")
print( "abc" <= "ABC")

逻辑运算符

逻辑运算符一般用来解决当有多个关系条件需要判断时使用，用来确定这些条件组合的方式，运算结果为布尔类型值。

Python 中提供的逻辑运算符如下表所示：

运算符1	逻辑表达式	描述
and	x and y	逻辑"与" ： 如果 x 为 False，x and y 返回 False，否则它返回 y的计算值。
or	x or y	逻辑"或" ： 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。
not	not x	逻辑"非" ： 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

逻辑与运算符 and

逻辑与运算符用来连接多个关系条件运算，只有当多个条件同时满足时，结果为真 True，否则为假 False

print(3 > 2 and 2 > 1)
print(3 < 2 and 2 > 1)
print(3 < 2 and 2 < 1)
print(1 < 2 and "H" + "W")

逻辑或运算符 or

逻辑或运算符用来连接多个关系条件运算，只有当多个条件同时不满足时，结果为假 False，只要其中有一个条件为真，结果即为真 True

print(3 > 2 or 2 > 1)
print(3 < 2 or 2 > 1)
print(3 < 2 or 2 < 1)
print(1 > 2 and "H" + "w")

逻辑非运算符 not

逻辑非运算符用来对表达式结果进行取反运算，如果表达式结果为真，则取反结果为假 False，如果表达式结果为假，则结果即为真 True

print(not (3 > 2))
print(not (3 < 2))

短路特性

在使用 逻辑与 运算符和 逻辑或 运算符时，如果自左向右计算结果可以确定整个表达式的结果时，后面的表达式条件便不在计算。

非短路操作

result = True and print("Hello, World!1")  # 第一个操作数为True，不能确定后续都为真，所以print语句会执行
print(result)   # 输出 None，print语句的返回值为Noneresult = False or print("Hello, World!2")  # 第一个操作数为False，不能确定后续都为假，所以print语句会执行
print(result)  # 输出 None，print语句的返回值为None

短路操作

result = False and 1/0  # 第一个操作数为False，已经可以确认整个表达式的结果，虽然表达式有除0错误，但并不会执行
print(result)  # 结果为Falseresult = True or 1/0  # 第一个操作数为True，已经可以确认整个表达式的结果，虽然表达式有除0错误，但并不会执行
print(result)  # 结果为True

成员运算符

Python 提供了成员运算符，用于判断实例中是否包含了一系列的成员，包括字符串，列表或元组。

如下表所示：

项目	Value
in	如果在指定的序列中找到值返回 True，否则返回 False。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。

成员运算符 in

如果被查询成员在目标中存在，结果为真 True，如果不存在，结果为假 False

print("o" in "Hogwarts")
print("K" in "Hogwarts")
print(0 in [1,2,3,4,5])
print(3 in [1,2,3,4,5])

成员运算符 not in

如果被查询成员在目标中不存在，结果为真 True，如果存在，结果为假 False

print("o" not in "Hogwarts")
print("K" not in "Hogwarts")
print(0 not in [1,2,3,4,5])
print(3 not in [1,2,3,4,5])

身份运算符

Python 中的身份运算符用来判断两个对象的引用是否为同一个，换言之，就是用来比较两个对象的内存地址是否相同。

Python 对数字和字符串做了一些优化以提高性能和减少内存开销。以下是 Python 对数字和字符串做的一些优化：

1. 整数池（Integer Pool）：Python
   会在程序运行时预先创建一些整数对象，并将其保存在整数池中。这样，在创建整数对象时，可以重用已存在的对象，而不是创建新的对象。这在一定程度上减少了内存开销。
2. 字符串池（String Pool）：对于较短的字符串，Python
   会使用字符串池进行优化。字符串池是一个缓存区，保存着所有共享相同内容的字符串对象。当创建新的字符串对象时，Python
   会首先检查是否已经存在相同内容的字符串对象，如果存在，则直接重用已有的对象，避免重复创建新的对象。

因此，在某些情况下，字面量相同的两个对象，实际并不是同一个对象，此时如果需要区分对象的话，就需要使用身份运算符。

身份运算符如下表所示：

项目	Value
is	is 是判断两个标识符是不是引用自一个对象
is not	is not 是判断两个标识符是不是引用自不同对象

身份运算符 is

is 用来判断两个对象内存引用地址是否相同，如果相同，结果为真 True，如果不相同，结果为假 False

# 示例 1
str1 = "Hello"
str2 = "Hello"
print(id(str1))  # 输出第一个字符串对象的内存地址
print(id(str2))  # 输出第二个字符串对象的内存地址
print(str1 == str2)
print(str1 is str2)# 示例 2
str3 = "Hello, World!" * 1000
str4 = "Hello, World!" * 1000
print(id(str3))  # 输出第一个字符串对象的内存地址
print(id(str4))  # 输出第二个字符串对象的内存地址
print(str3 == str4)
print(str3 is str4)

注意：两个字面量相同的对象，内存地址未必相同，就像两个双胞胎，长的相同，但是是两个独立的个体。

身份运算符 is not

is not 用来判断两个对象内存引用地址是否不同，如果不同，结果为真 True，如果相同，结果为假 False

# 示例 1
str1 = "Hello"
str2 = "Hello"
print(id(str1))  # 输出第一个字符串对象的内存地址
print(id(str2))  # 输出第二个字符串对象的内存地址
print(str1 == str2)
print(str1 is not str2)# 示例 2
str3 = "Hello, World!" * 1000
str4 = "Hello, World!" * 1000
print(id(str3))  # 输出第一个字符串对象的内存地址
print(id(str4))  # 输出第二个字符串对象的内存地址
print(str3 == str4)
print(str3 is not str4)

is 和 == 的区别

在 Python 中，万物皆对象，而对象的三个基本要素:

• 内存地址

• 数据类型

• 值
  而 is 与 == 都作为常用的判断语句去进行使用，这两者之间的主要区别是：

• == 运算符: 只比较两个对象的值，相同返回 True，不同返回 False。

• is 运算符: 比较两个对象的地址引用，相同返回 True，不同返回 False。

在这种场景下， 两个判断的执行结果均为 True。

a, b = 1,1
# 判断a，b 是否相等
print(a == b)
print(a is b)

在这种场景下， 两个判断的执行结果不一致。

a = [1,2,3]
b = [1,2,3]
# 对比值一致，返回True
print(a == b)
# 对比内存地址不一致，返回False
print(a is b)

三目运算符

三目运算符也称为三元运算符，是指运算符在使用时，需要有三个操作数参与计算。

Python 中也提供三目运算符，但语法上与传统的三目运算符并不相同。

可以将 Python 中的三目运算符理解成是 if-else 分支语句的简化单行模式

语法格式： [on_true] if [expression] else [on_false]

• on_true: 条件为真时的结果

• on_false: 条件为假时的结果

• expression: 判断条件
  Python 会先判断 expression 条件表达式的结果：

• 如果条件为真，则结果为 [on_true] 的值

• 如果条件为假，则结果为 [on_false] 的值

print("Yes" if True else "No")
print("Yes" if False else "No")

tips：
输入一个4位年份，判断是否是闰年 判断条件：能被4整除但不能被100整除，或能被400整除

year = int(input())
result = "Yes" if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0) else "No"
print(result)

运算符优先级

Python 中的运算符非常丰富，但在使用过程中除了需要注意各自的特性外，不同的运算符也具有不同的优先级别。

Python 运算符优先级如下表所示：

项目	Value
(expressions…)	绑定或加圆括号的表达式
[expressions…]， {key: value…}， {expressions…}	列表显示，字典显示，集合显示
x[index]， x[index:index]， x(arguments…)， x.attribute	抽取，切片，调用，属性引用
**	乘方
**	乘方
**	乘方
+x， -x	正，负
*， @， /， //， %	乘，矩阵乘，除，整除，取余
+， -	加和减
in， not in， is， is not， <， <=， >， >=， !=， ==	比较运算，包括成员检测和标识号检测
not	逻辑非
and	逻辑与
or	逻辑或
if – else	条件表达式
=， +=， -=， *=， /=， //=， **=	赋值表达式
注意：

因为位运算在后期课程使用过程中使用场景非常少，所以在本课程中并没有讲解（不代表在其它场景中不会使用）。

小技巧：

如果在使用运算符的过程中，不能很好的掌握其优先级顺序，最简单的办法就是在需要先计算的表达式上加括号

print((2+3)*5)

tips：
从键盘输入一个3位数字字符串，将其转换为数字，并逆序，不允许使用切片，不需要做判断

num = int(input("请输入一个三位数字："))
a = num // 100
b = num % 100 // 10
c = num % 10
result = c*100 + b*10 + a
print(c,b,a,sep="")
print(result)