python测试开发班-28期-yf-python学习笔记-语法与数据结构

学习笔记
1

python 基础语法

输入与输出

1.input（）函数获取键盘输入，键盘输入任何数据以字符串保存,input()函数返回字符串
例如：
name=input()
print(name)
2.print（）函数输出文本和变量
格式：print（values,sep=“”,end=“\n”）
values:需要输出的数据
sep=“” ：多个数据之间的分割符，默认一个空格
print(“Hello”, “Python”, 20, True, sep=‘—’)

end=“\n”:一次输出后的结束符，默认为换行符

函数定义

函数是一段可重复使用的代码块，它执行特定的任务并返回一个结果。

在编程中，函数用于将一段代码逻辑封装起来，以便在需要时可以方便地调用
函数主要目的是提高代码的重用性和可维护性
函数组成：
1.函数名：函数名用于标识函数，以便在代码中调用它时使用
2.函数的的传入参数：函数执行需要的数据
3.函数体：函数体是函数的实际代码逻辑，
4.返回值：返回值是函数体代码执行过后的运行结果
内置函数：
开发语言中定义好的特定功能函数，可直接使用
函数定义：
定义好的特定功能函数不足以使用，大部分自己开发自定义函数
语法形式：
def function_name([parameter_list]):
[‘’‘注释信息’‘’]
[function_body]
return [result]
def：自定义函数关键字
function_name:函数名称，在函数调用时使用，命名规范要符合实际应用
（）函数的特征，用来书写参数列表
parameter_list：函数参数，接收的外部数据
：固定语法
function_body 函数体，实现函数功能的逻辑代码
return：函数返回值
函数调用
function_name([parameters_value])

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

标识符号

###命名规范
4项原则
1.见名知意
2.不能使用关键字
3. 标识符由英文字母、下划线_和数字组成，但不能以数字开头
4. 区分大小，大小写敏感

关键字

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

变量

变量的概念：
处理数据需要使用变量表示数据，变量就是用来表示数据的名字
变量的定义：
将数据通过等号(=)赋值给一个符合命名规范的标识符
变量的使用
指在程序中引用一个已经定义的变量
变量的地址：
内置函数 id() 可以获取变量的内存地址，也就是这个变量在计算机内存中的唯一标识，通常是用一串数字表示
每个变量在内存中都有一个唯一的地址，通过比较两个变量的内存地址，可以判断它们是否是同一个变量

python数据类型

python3 中标准数据类型：

number 数字
String 字符串
bool 布尔类型
复合数据类型：容器类型
list 列表
Tuple 元组
Dictionary（字典）
Set 集合
···空类型
None
根据数据特性可分为：
··>不可变数据（4个）：
number 数字 、 bool 布尔 、String （字符串） 、 Tuple（元组）
··>可变数据3个
list 列表 Dictionary 字典 set 集合
类型查看
type(变量)

数字类型

· 整数： 用来表示整数数值，即没有小数部分的数值，在 Python 中，没有 Long 类型，统一使用 int 类型表示
· 浮点数： 没有 Double 类型，统一使用 float 类型表示
· 复数：

布尔类型

布尔类型只有两个值，即 True 和 False 表示真和假，在 Python 中，布尔类型通常用于判断逻辑关系和状态标记
条件判断：
判断某个条件真假
状态标记：
程序开发过程中，经常需要标记一些状态，比如是否选中，是否点击等，都可以使用记录布尔值的变量记录状态
isSelect
isExist

类型转换

·· 自动转换
自动转换也称为隐式类型转换，程序在执行过程中自动完成，将数据精度低转换为数据精度高的类型
n = 10 + 3.14 转换为浮点数
n = False + 1 转换成整型

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

比如通过 input() 函数获取的数字，实际为一个数字字符串，如果需要进行计算，需要将其转换成真正的数字才能进行数据计算
不能转换，会导致出错或无法正常运行
Python 提供了多种类型转换的函数
int(x)：将 x 转换为整数
float(x)：将 x 转换为浮点数
complex(x)：将 x 转换为复数
bool(x)：将 x 转换为布尔值。如果 x 是一个空对象、0、空字符串、空列表、空元组、空字典或者 False，那么将返回 False，否则将返回 True
str(x)：将 x 转换为字符串
chr(x): 将一个整数转换为一个字符
如果在强制类型转换时，传递的转换数据不合法导致无法转换，那么将会抛出异常

python运算符
运算符概念：运算符是用于进行各种运算操作的符号或关键词

Python 语言常用运算符：
··算术运算符：+ 加法 ，- 减法 *乘法 / 除法
% 取模，两个操作相除，取余数为计算结果
** 幂运算 ：返回x的y次幂
// 整除 ： 两个操作数相除，取商，结果为整数类型
··比较运算符/关系运算符

运算符 描述
== 等于 ： 比较对象是否相等
!= 不等于 ： 比较两个对象是否不相等
> 大于 ： 返回x是否大于y
< 小于 ： 返回x是否小于y
>= 大于等于 ： 返回x是否大于等于y。
<= 小于等于 ： 返回x是否小于等于y。
··赋值运算符
运算符 描述
— —
= 简单的赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符
··逻辑运算符
运算符 描述
and 逻辑与 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or 逻辑或 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。
not 逻辑非:如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

··成员运算符

运算符 描述
in 如果在指定的序列中找到值返回 True，否则返回 False。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。

··身份运算符

运算符 描述
is is 是判断两个标识符是不是引用自一个对象
is not is not 是判断两个标识符是不是引用自不同对象

is 和 == 的区别

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

  • 内存地址
  • 数据类型
  • 值

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

  • == 运算符: 只比较两个对象的值，相同返回 True，不同返回 False。
  • is 运算符: 比较两个对象的id，相同返回 True，不同返回 False
    is 比较内存地址
    ··运算符优先级
    Python 运算符优先级如下表所示：
运算符 描述
(expressions…) 绑定或加圆括号的表达式
[expressions…]， {key: value…}， 列表显示，字典显示，集合显示
x[index]， x[index:index]， x(arguments…)， x.attribute 抽取，切片，调用，属性引用
** 乘方 5
+x， -x 正，负
*， @， /， //， % 乘，矩阵乘，除，整除，取余 6
+， - 加和减
in， not in， is， is not， <， <=， >， >=， !=， == 比较运算，包括成员检测和标识号检测
not 布尔逻辑非 NOT
and 布尔逻辑与 AND
or 布尔逻辑或 OR
if – else 条件表达式
=， +=， -=， *=， /=， //=， **= 赋值表达式

根据使用操作数的不同，可分为：

  • 单目运算符

  • 双目运算符

  • 三目运算符
    语法格式： [on_true] if [expression] else [on_false]

  • on_true: 条件为真时的结果

  • on_false: 条件为假时的结果

  • expression: 判断条件
    例如：
    print(“Yes” if True else “No”)
    print(“Yes” if False else “No”)

数据结构

字符串：字符串是由引号包裹的任意字符组成的不可变序列，用于表示文本类型数据
可以通过使用单引号 或双引号 或三引号 来定义
转义字符
\n 表示换行符，\t 表示制表符，\" 表示双引号，\' 表示单引号，\\ 表示反斜杠。
字符串下标： 下标是指从 0 开始的数字编号，也称为索引，越界会报错
字符串常用函数方法：
len():获取参数字符串的字符个数，返回值类型为int
count(): 返回 str 在 string 里面出现的次数，如果 start 或者 end 指定则返回指定范围内 str 出现的次数 格式：count(str, start, end)，返回值为int
index：
index() 检测 sub 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则抛出一个异常 格式：index(sub, start, end)，返回值是int，字符出现的位置参数
rindex() 作用同 index() ,查找子串时从右侧查找，若找不到会抛出一个异常 格式：rindex(sub, start, end)
find() 检测 sub 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 格式，返回值为int类型
rfind ：rfind() 作用同 find() ,查找子串时从右侧查找，若找不到会抛出一个异常 格式：rfind(sub, start, end)
replace() 把 string 中的 old 替换成 new,如果 max 指定，则替换不超过 max 次. 格式：replace(old, new, max)

字符串格式化

format()方法是一种传统的字符串格式化方法。它使用占位符 {} 来表示要插入的变量或值，并通过传递参数来替换这些占位符
在调用 format() 方法时，通过参数的顺序将相应的值传递给占位符，从而替换字符串中的占位符部分
通过在 format() 方法中按照顺序传递相应的参数，就可以根据索引号将值插入到指定的位置
format()方法还支持使用关键字参数来指定变量或值的插入位置

在 format() 方法中，还可以使用格式化选项来控制插入值的格式，如字段宽度、对齐方式、小数点精度等
{:.2f} 是一个格式化选项，它指定了插入的值应该被格式化为带有两位小数的浮点数
例如：
pi = 3.141592653589793
formatted_pi = “The value of pi is approximately {:.2f}”.format(pi)
输出：the value of pi is approximately 3.14

f-string是Python 3.6及更高版本引入的一种简洁且直观的字符串格式化方法。它使用前缀f 定义字符串，并使用花括号 {} 来插入变量或值
f-string 的格式化选项方式使用同 format()函数一致

在f-string中，可以使用表达式和函数调用来生成动态的字符串内容

字符串格式化的更多用法

除了简单的变量插入，字符串格式化还支持更多的格式控制选项

  • 设置字段宽度和对齐方式
  • 控制字段宽度和对齐方式
  • 设置小数点精度和浮点数格式化
  • 格式化日期和时间
  • 格式化数字的千位分隔符
  • 使用填充字符进行对齐
  • 格式化二进制、十六进制和其他进制数值

总结：
总结

  • 字符串格式化是将变量或值插入到字符串中的特定位置的过程。
  • Python提供了多种字符串格式化的方法，包括format()方法和f-string。
  • format()方法使用占位符 {} 进行变量插入。
  • f-string使用前缀f定义字符串，并使用花括号 {} 进行变量插入。
  • 字符串格式化还支持更多的格式控制选项，例如字段宽度、小数点精度等。
  • 通过掌握字符串格式化的方法，你可以在字符串中动态地插入变量或值，创造出灵活且有动态内容的字符串。这将提高你的编程效率并增强代码的可读性

元组

元组是一种数据类型，在Python中用于存储多个元素，元组是有序的数字结构，元组是不可变的，元组是异构的可以包含不同类型的元素
元组的字面量定义
元组使用小括号 () 来定义,元组中的元素通过逗号 , 进行分隔，每个元素都可以是不同的数据类型
使用小括号 () 来创建一个空元组。如果没有任何元素需要添加到元组中，空无组没有任何实际意义
定义无组时，逗号是必须的，即使元组只包含一个元素，也需要在元素后面加上逗号,以区分它是一个元组而不是其他数据类型。

元组的构造方法定义
可以通过元组的构造方法定义元组。 当使用构造方法定义元组时，参数只能是可迭代的对象，构造方法会将参数中的元素构造成为元组的元素。 可以理解为将可迭代的对象强制类型转换为元组
元组中元素的引用
元组同字符串一样，也可以使用下标形式引用元组中的元素。并且，下标不能超过元组的元素个数减1，否则会抛出下标越界错误
元组切片：元组的切片操作同字符串一致

元组特点：
有序性：元组中的元素按照添加顺序进行存储，并且可以通过索引来访问和引用。这意味着元组中的元素保持其原始顺序，不会发生改变
不可变性：元组的元素是不可修改、删除或添加的

元组的应用场景：
存储一组不可变的数据
作为字典的键值对
函数多个返回值

元组的常用方法：
len() 获取元组元素个数 格式：len（元组对象）
count() 统计元组中参数 value 指定值的个数
index() 在元组中查找 value 第一次出现的下标。如果指定了范围，则仅在指定范围内查找

列表

列表是一种有序、可变，异构的数据集合，可以存储多个不同类型的元素
特点：

  • 有序性：列表中的元素按照添加的顺序进行存储，每个元素都有一个对应的索引，可以通过索引访问和操作列表中的元素。
  • 可变性：列表是可变的，也就是说可以通过索引来修改、删除或插入元素。可以改变列表的长度、内容和顺序。
  • 可存储不同类型的元素：列表中可以同时存储不同类型的数据，例如整数、字符串、浮点数、布尔值等。甚至可以存储其他列表或其他复杂的数据结构

列表定义
Python 中使用中括号定义列表
例如：
l1 = # 创建一个空列表
由于列表具有可变性，所以空列表的定义是被允许且有意义的

列表的构造方法定义

可能通过列表的构造方法定义列表。 当使用构造方法定义列表时，参数只能是可迭代的对象，构造方法会将参数中的元素构造成为列表的元素。 可以理解为将可迭代的对象强制类型转换为列表

列表元素的引用
列表同字符串，元组一样，也可以使用下标形式引用列表中的元素
列表中元素的修改
由于列表的可变特性，可以通过下标的方式，对列表中的元素进行赋值修改

列表的切片
列表的切片操作同字符串，元组一致
例如：
l = [1,2,3,4,5]
print(l[0:3])
print(l[:3])
print(l[3:])
print(l[:])
print(l[::-1])
列表的用途：
存储一组相关的数据
数据的容器
算法和数据结构中的应用

列表操作

len(列表对象)，获取列表元素个数
count（value）在列表中统计参数value出现的次数
index(value, start, stop) 在列表中查找参数 value 第一次出现的下标位置
增加元素：
append（value）向列表最后追加元素
extend(iterable) 将一个可迭代对象的元素依次添加到列表最后 insert(index, value) 向列表指定下标位置插入一个元素，原有元素依次后移，如果指定下标超过元素个数，则插入到列表最后
删除元素
del 可以使用 del 关键字结合索引来删除指定位置的元素。如果指定的下标不存在则抛出一个错误。
remove(value) 在列表中删除第一个指定的数据，如果删除的数据不存在则抛出错误 pop(index) 从列表中取出并删除指定下标位置的元素，默认取出并删除最后一个元素，如果指定下标不存在，则会抛出一个错误
clear() 清空列表
列表排序
sort(key, reverse) 对列表进行排序

  • ort方法默认对基本数据类型进行升序排序
  • reverse参数将列表元素排序后将列表逆序，实现降序排序
  • key 参数用来指定排序规则，比如使用学生的年龄进行排序（此处不讲解该参数的使用，在lambda处讲解）

列表和元组的区别

相同点：元组和列表在Python中，都是有序的，可迭代的数据结构。
元组和列表都是异构的，都可以存放不同数据类型的元素。
不同点：元组是不可变的，不可以进行增删改操作，一旦定义，无法修改
列表是可变的，可以对列表中的元素进行增删改操作，空列表有实际意义，空元组无意义
内存占用不同：
由于元组与列表内部的实现机制不同，在相同元素和个数的情况下，元组占用内存空间更小
总结对比

对比 元组 列表
定义 (1, 2, 3) [1, 2, 3]
修改 不支持 支持
添加 不支持 支持
删除 不支持 支持
索引访问 支持 支持
切片 支持 支持
遍历 支持 支持
应用场景 固定的，不会被修改的数据 不固定的，可以被修改的数据
占用内存 较小 较大

字典

字典定义
字典是Python中的一种容器数据类型，用于存储键值对（key-value）的数据集合
Python 中使用花括号，保存key-value形式表示字典
key 必须是一个可哈希的对象，可以使用 hash() 函数来判断数据是否可哈希。
字典的字面量定义
d1={}
d2 = {“name”: “Alice”, “age”: 25, “gender”: “female”}
构造方法定义字典
d1 = dict(one=1, two=2, three=3)
d2 = dict([(‘two’, 2), (‘one’, 1), (‘three’, 3)])
d3 = dict(((‘two’, 2), (‘one’, 1), (‘three’, 3)))
d4 = dict([(‘two’, 2), [‘one’, 1], (‘three’, 3)])
d5 = dict({‘one’: 1, ‘two’: 2, ‘three’: 3})
d6 = dict({‘one’: 1, ‘three’: 3}, two=2)
解包方法
d7 = dict(zip([‘one’, ‘two’, ‘three’], [1, 2, 3]))

字典数据访问
字典使用 key 来获取对应的键值
格式：字典对象[key]
例如
stu = {“name”:“Tom”, “age”: 23, “gender”:“male”}
print(stu[“name”])
print(stu[“age”])

字典元素添加与修改

字典中的每一个元素都以键值对形式表示，一个key对应一个value, 在一个字典中，key具有唯一性，当给一个key赋值时，如果key在当前字典中不存在，则是添加数据，如果key存在，则对当前key所对应的值进行修改更新

格式：字典对象[key] = value
例如：
stu = {“name”:“Tom”, “age”: 23, “gender”:“male”}
print(stu)
添加新元素
stu[“address”] = “BeiJing”
print(stu)
修改数据
stu[“name”] = “Jack”
stu[“address”] = “ShangHai”
print(stu)
字典元素的删除
字典也可以使用 del 通过key删除元素,当删除元素时，整个键值对都会被删除。
格式：del 字典对象[key]
例如：
stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
print(stu)
删除元素
del stu[‘age’]
print(stu)
在Python 3.7及更高版本中，字典被认为是有序的，即它们可以保持键值对的添加顺序。这意味着当遍历字典或打印字典时，键值对的顺序与它们添加到字典中的顺序相同。这种有序性是字典的内置特性，不需要额外的操作
在Python 3.6及更早版本中，字典是无序的，无法保持键值对的顺序。这意味着当遍历字典或打印字典时，键值对的顺序是不确定的，可能与它们添加到字典中的顺序不同
如果在编程中需要依赖字典键值对的顺序，建议使用Python 3.7及更高版本以确保有序性
字典的应用场景
字典适用于存储具有相关性的数据
字典提供了快速查找和访问数据的能力，通过键可以直接定位对应的值，而不需要遍历整个字典
字典作为数据的容器，提供了丰富的操作方法，可以方便地进行遍历、搜索、插入和删除操作

字典操作

keys() 用来获取字典中所有的 key, 保存到一个列表中，并以 dict_keys 类型返回
values() 用来获取字典中所有的value, 保存到一个列表中，并以 dict_values 类型返回
items() 用来获取字典中所有的键值对，每一个元素键值对都以一个元组保存，将所有元素元组保存到一个列表中，并以 dict_items 类型返回
get(key, default) 用来获取key对应的值，如果指定的key不存在，则返回默认值
例如：
stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
print(stu.get(“name”))
print(stu.get(“hobby”))
print(stu.get(“hobby”,“无数据”))

字典添加更新操作
setdefault(key,default)给一个不存在的key添加一个默认值并将该键值对保存到字典中 在一些场景下，字典的key存在，但是该key却没有对应的值，此时，就可以使用该方法，为当前的key添加一个默认值。比如服务端要保存客户端发起请求时携带的请求头中的信息fromkeys(keys,val) 用于创建一个新字典，以序列 keys 中元素做字典的键，value 为字典所有键对应的初始值,默认为None`
例如：
ks = (“name”, “age”, “gender”)
s1 = dict.fromkeys(ks)
print(s1)

s2 = dict.fromkeys(ks,“无”)
print(s2)
输出结果：
image

update(d/iterable) 使用参数中的数据更新当前字典
该方法的参数可以接收一个字典（大多数的使用方式），也可以接收一个可迭代对象，如果参数数据中的key在当前字典中存在，则使用新值更新字典中的键值对，如果参数数据中的key在当前字内中不存在，则将键值对添加到当前字典中

更新目标数据是一个字典

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
newStu = {“name”:“Jack”,“hobby”:“eat”}
stu.update(newStu)
print(stu)

更新目标数据是一个可迭代对象

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
newStu = ((“name”,“Rose”),[“hobby”,“play”])
stu.update(newStu)
print(stu)
输出结果：

image
image1111×129 12.3 KB

字典删除操作
popitem() 用来获取并删除字典中的最后一个键值对，返回一个元组，如果字典为空，抛出错误
pop(key) 用于获取并删除字典中指定key对应的键值对。如果指定的key不存在，则抛出错误
clear() 清空字典中所有的键值对元素

集合

集合概念特性：
集合是一种数据类型，用于存储多个元素，并确保元素的唯一性
集合中的元素是无序的，不可以通过索引或切片进行访问
集合的主要特点是元素不重复，相同的元素在集合中只会出现一次
可以使用大括号 {} 或 set() 函数来定义和创建集合
集合提供了各种集合运算，如并集（两个集合中的所有元素）、交集（两个集合中共有的元素）、差集（第一个集合中存在而第二个集合中不存在的元素）等操作
集合的创建
不能使用 {} 创建一个空集合，因为此种方式创建的类型为字典
s2 = {} #定义成字典类型，而不是集合类型
集合元素具有唯一性
s = {1,1,1,2,3,4,5,6,6,6,6,6,6,6}
print(s)
集合常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等

集合操作：
add(ele) 向集合中添加一个元素,如果元素则不产生任何影响
update(others)更新集合，添加来自 others 中的所有元素,others是一个可迭代对象，如果数据在集合中存在则不更新 *pop()从集合中移除并返回任意一个元素，如果集合为空，则抛出错误remove(elem)从集合中移除元素 elem。 如果 elem 不存在于集合中则抛出错误 discard(elem) 如果元素 elem 存在于集合中则将其移除，如果elem不存在，则什么也不做 *clear() 清空集合
isdisjoint(other) 如果集合中没有与 other 共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合
issubset(other) 检测是否集合中的每个元素都在 other 之中
issuperset(other) 检测是否 other 中的每个元素都在集合之中
union(*other) 返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素,other可以指定多个集合
intersection(*others) 返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素

深拷贝与浅拷贝

拷贝是指使用一个已存在一个对象，生成一个新的对象，两个对象在内存中具有独立的存储空间
浅拷贝是指创建一个新的对象，只拷贝内容是原始对象的引用，而不是创建原始对象的副本数据
深拷贝是指创建一个新的对象，并递归地复制原始对象及其所有嵌套对象的内容，而不仅仅是复制它们的引用
浅拷贝不具有数据独立性，对象的 copy() 方法，copy 模块的copy() 方法，工厂方法，切片等方式得到的都是浅拷贝对象
深拷贝具有数据独立性，使用 copy 模块中的 deepcopy() 方法实现深拷贝
程序大部分实现的都是浅拷贝
浅拷贝，深拷贝特指容器类型保存的复杂结构，对于基本类型的数据，都是引用指向
sorted是深拷贝
浅拷贝 copy（）
深拷贝
原始数据
originData = [[1,2],{“name”:“Tom”, “chars”:[“A”,“B”]}]

使用 copy模块中的deepcopy方法获取深拷贝对象
deepCopyData = copy.deepcopy(originData)

分支语句-if

  • 什么是分支语句
    程序中的选择语句，也称为条件语句，即按照条件选择执行不同 的代码片段

if 条件判断
if 保留字来组成选择语句
if 表达式：
语句快
表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式
如果表达式为真，执行语句块。如果表达式为假，跳出语句块

if … else
只能二选一的条件，Python 中提供了 if…else 语句解决类似问题

if… elif… else 多重条件

分支嵌套
在最简单的 if 语句中嵌套 if…else 语句,也能在 else 语句中嵌套,还能在 elif 语句中嵌套
if 选择语句可以有多种嵌套方式，在开发程序时，可以根据自身需要选择在合适的分支基础上进行嵌套，但一定要严格控制好不同级别代码块的缩进量

匹配语句
在 Python 中，match 是 Python 3.10 版本引入的一种模式匹配语法
提供了一种简洁而强大的方式来匹配和处理不同模式的逻辑，当成功匹配一个模式时，就执行该模式后的代码块
match 语句适用于有限的精准值的匹配，不适用于范围值的判断
语法结构：
match value:
case pattern1:
# 处理 pattern1 匹配成功的情况
case pattern2:
# 处理 pattern2 匹配成功的情况
…
case patternN:
# 处理 patternN 匹配成功的情况
case _:
# 处理所有其他情况的匹配（相当于默认情况）
macth 表示匹配模式开始
value表示需要匹配的目标值
case 表示提供一个匹配模式
pattern 表示被匹配的值，该值一般为一个字面量值
- 表示当所有模式都未匹配成功，则执行该模式下的代码块
组合多个匹配值
match 可以在一个匹配模式中，提供多个匹配值，使用 | 组合，在匹配时，只要成功匹配其中一个值即可

在提供匹配值时，除可以提供字面值外，还可以提供变量，用来匹配任意值，如_ ,但是在一个匹配语句中，只能出现一个独立的匹配变量

如果需要动态匹配部分数据，比如一个元组中的部分值，此时可以通过绑定变量的方式，提供一个字面值和变量的混合匹配模式，字面值用来精确匹配，变量用来模糊匹配

循环语句 -while

有些事物必须周而复始地运转才能保证其存在的意义，无法一次解决的事务，使用循环
循环两种类型：
重复一定次数的循环，称为计次循环
一直重复，直到条件不满足时才结束的循环，称为条件循环。只要条件为真，这种循环会一直持续下去，如 while 循环
循环的作用
提高代码的重复性，减少代码冗余
遍历序列（字符串，元组，列表，字典等）
循环的构成要素
初始化语句
循环条件
循环体
迭代语句

什么是 while 循环
只要循环条件为真，这种循环会一直持续下去，通常指的是 while 循环
只要条件为真，这种循环会一直持续下去，通常指的是 while 循环。

for in循环
Python并没有提供类似C语言中那种传统意义上的for循环，而是提供了一种专门处理字符串，元组，列表，字典等可迭代的序列类型数据的增强型for循环
语法：
for 迭代变量 in 对象:
循环体
for-in 循环会将可迭代对象中的元素依次取出，保存到迭代变量中。每取出一个变量，便执行一次循环体，在循环体中可以通过引用迭代变量，使用取出的数据
遍历迭代对象，
遍历字符串
遍历元组
遍历列表
遍历字典
在使用for-in遍历字典时，默认遍历的是字典的所有key
遍历键值 for method in requestMethods.keys():
通过遍历访问每个键和键值

循环跳转

在使用循环进行实现逻辑时，并不是每次都会将循环执行完毕，或者循环根本没有结束的条件，此时，在循环过程中，期望达到某个条件时，结束循环继续向后执行，此时，就可以使用循环跳转来完成此功能：

  • break 结束当前循环

  • continue 结束本次循环

break 语句可以中止当前的while 或for-in循环，无论循环还有多少次没有循环，都会无条件结束循环后，跳转到循环后的语句继续执行
break 语句出现在多层循环中时，所处在哪个循环的循环体内，就跳出哪个循环，更外层的循环不受影响

continue 语句
continue 语句的作用用来中止本次循环而提前进入下一次循环中，循环体中未执行完的代码不在执行

loop-else
不只if 语句可以使用else, 循环语句也可以使用else
当一个循环没有被break中断而正常循环结束，就会执行else后的代码块

python函数

函数返回值与参数处理

函数的主要作用是实现模块化代码，减少代码在程序中的冗余，提高代码的复用率
函数通过接收一定的数据，根据业务逻辑进行相应的处理，然后将处理结果返回给调用者
实现函数要基于高内聚，低耦合的思想
通过遵循函数的高内聚低耦合原则，可以带来以下优点
可维护性
可测试性
可复用性
灵活性

函数的返回值
return 结束函数执行，返回值给调用者
函数只能返回一个值
一个函数只能返回一个结果值，当需要返回多个值时，需要进行包装处理
组包与解包
当将多个值，同时赋给一个变量时，Python会进行自动组包操作，将所有的数字组合成一个元组，再将元组赋值给变量。 当使用一个元组为多个变量进行赋值时，Python会将元组中的元素值，依次赋值给变量，这称为解包操作

多个return语句
在一个函数中，允许有多个return语句，可以实现在不同的条件下，返回不同的值，但同一时刻，只能有一个return语句被执行

参数传递
参数是指函数在完成特定功能时，需要外部传递的数据
在程序中，函数调用时指定数据的过程，称为参数传递

  • 主调函数：主动调用其它函数执行的称为主调函数。
  • 被调函数：被动调用执行的函数称为被调函数。
  • 实际参数：在调用函数的时候，函数名称后面括号中的数据即为实际参数，简称实参，通俗讲就是实际值。
  • 形式参数：在定义函数的时候，函数名称后面括号中的变量即为形式参数，称称形参，通俗讲就是一个记号

位置参数

位置参数也称为必备参数，必须按照正确的顺序传到函数中，即调用时的数量和位置必须 和定义时是一样的。

  • 数量必须与定义时一致，在调用函数时，指定的实际参数的数量必须与形式参数的数量一致，否则将抛出 TypeError 异常，提示缺少必要的位置参数（missing x required positional argument）。
  • 位置必须与定义时一致，在调用函数时，指定的实际参数的位置必须与形式参数的位置一致，否则将抛出 TypeError 异常或者结果与预期不符的情况，例如入参的位置 1 需要一个 int 类型参数，而入参 2 位置需要一个 str 类型的参数，如果传递的位置不正确，那么 str 类型数据传递进去之后会报类型错误的异常；位置参数是会按照顺序进行参数的替换的

关键字参数
关键字参数是指使用形式参数的名字来确定输入的参数值，通过该方式指定实际参数时，不再需要与形式参数的位置完全一致，只要将参数名写正确即可，这样可以避免用户需要牢记参数位置的麻烦，使得函数的调用和参数传递更加灵活方便

变量和作用域

python的作用域一共有四种，
l：最内层，包含局部变量，一个函数的内部
E：包含了非局部(non-local)也非全局(non-global)的变量，一般在闭包中出现。
G:当前脚本的最外层，比如当前模块的全局变量
B:包含了内建的变量/关键字等，最后被搜索
根据作用域的不同，变量可分为局部变量和全局全量

匿名函数

匿名函数是指没有名字的函数，应用在需要一个函数，但是又不想费神去命名这个函数的场合。在通常情况下，这样的函数只使用一次
使用 lambda 表达式创建匿名函数

  • Lambda 函数可用于任何需要函数对象的地方。
  • 在语法上，匿名函数只能是单个表达式。
  • 在语义上，它只是常规函数定义的语法糖。
  • lambda 表达式中不能使用 if,for,while, return等语句, 但可以使用三目运算符
    使用场景：需要一个函数，但是又不想费神去命名这个函数
  • 通常在这个函数只使用一次的场景下
  • 可以指定短小的回调函数
    例如：
    func = lambda x: x ** 2 if x > 3 else x ** 3
    print(func(4))
    解析，大于3输出X平方，小于等于三输出X三次方