Python测开28期-Camille-学习笔记-python基础

Camille · 2023 年11 月 19 日 05:19

python基础
1.python和pycharm下载和安装

2.pycharm快捷键

Ctrl+F 搜索
Ctrl+R 替换
Ctrl+ / 注释
Ctrl+D 复制当前光标所在行代码
Ctrl+ G 跳转到指定行:列
Ctrl +Alt+L 格式化代码
Alt+Enter 问题修复
Ctrl（Alt)+shift+上下方向键上下移动光标所在行代码

3.编码规范

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

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

注释：

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

#我是一段注释

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

‘’’
可以使用
三单引号
实现
多行注释
‘’’

“”"
可以使用
三双引号
实现
多行注释
“”"

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

命名规范

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

4.输入输出
input输入函数，从键盘获取输入数据，且输入的任何数据，都以字符串形式保存到程序中（加入提示信息更友好）。

输入函数 input()

s = input()
print(int(s) + 1)

数字字符串，无法进行计算(输入的任何数据，都以字符串形式保存到程序中)

msg = input(“请输入一段文本：”)
print(msg)

print输出函数，输出文本和变量。

输出一个数据

print(“Hello”)
print(123)

输出多个数据

print(“Hello”,“python”,1,2,3,4)

改变分隔符(指定分隔符)

print(1,2,3, sep=“–”)
print(1,2,3)

改变结束符

print(“Hello”,end=“”)
print(“World”,end=“–”)
print(“python”)

5.函数定义与调用
函数是一段可重复使用的代码块，它执行特定的任务并返回一个结果。
由函数名+参数+函数体+返回值组成
内置函数：预先定义好的实现特定功能的函数，可以直接使用，比如输入输出函数。
函数定义，满足实际开发需求
def function_name([parameter_list])
[‘’‘注释信息’‘’]
[function_body]
return[result]

函数定义

定义一个函数

def show():
“”" 这是一个显示函数，用来显示一段字符串 “”"
print(“Hello”)
print(“world”)
print(“python”)

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

语法格式：

function_name([parameters_value])

函数调用

print(“第一次调用函数”)
show()
print(“第二次调用函数”)
show()
print(“第三次调用函数”)
show()
print(“程序执行完毕”)

注意：

程序在执行到函数调用时，会跳转到函数定义位置执行函数体中的代码。
函数体执行结束后，将返回到函数调用处继续向后执行其它代码。

6.标识符
标识符是用来标识变量、函数、类、模块和其他对象的名称。需要注意的是，在定义标识符的时候，虽然很自由，但是也不能随心所欲，合法的标识符需要遵从一定的规范。
见名知意，如： get_name 、is_select 、name 、age 等都是符合规则的标识符命名
不能使用关键字，如： if 、else 、for 、def 等等
区分大小写，如： hogwarts 和 Hogwarts 是两个不同的标识符。
标识符由英文字母、下划线_和数字组成，但不能以数字开头，如： hogwarts666 是合法的标识符，而 666hogwarts 则是非法的标识符

关键字
关键字是指在 Python 编程语言中具有特殊含义的保留单词。这些关键字被 Python 解释器用于识别程序的结构和语义，从而执行相应的操作。
在 Python 中，关键字不可以用作变量名、函数名或其他标识符的名称，否则会导致语法错误。

导入内置关键字模块

import keyword

打印所有的关键字

print(keyword.kwlist)

查看系统关键字

导入系统关键字

import keyword

定义一个用来获取系统关键字的函数

def get_keyword():
kw = keyword.kwlist
print(kw)
print((len(kw)))

调用执行函数

get_keyword()

[‘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’]

35

变量
就是用来表示数据的名字
定义变量非常简单，只需将数据通过等号(=)赋值给一个符合命名规范的标识符即可。

name = "霍格沃兹"

变量的使用是指在程序中引用一个已经定义的变量
内置函数 id() 可以获取变量的内存地址，也就是这个变量在计算机内存中的唯一标识，通常是用一串数字表示
每个变量在内存中都有一个唯一的地址，通过比较两个变量的内存地址，可以判断它们是否是同一个变量。如果两个变量的内存地址相同，那么它们就是同一个变量

数据类型

基本数据类型
- Number（数字）
- String（字符串）
- bool（布尔类型）
复合数据类型（容器类型）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
- Set（集合）
空类型
- None

为了方便检查一个变量的具体类型，可以使用 Python 内置的 type() 函数查看变量的类型
def type_info():
print(type(1))
print(type(“Hello”))
print(type(3.14))

n = 1
print(type(n))
n = " 1 "
print(type(n))

type_info()

数字类型

数字类型（Number) 包括整数(int)、浮点(float)数和复数(complex) 三个子类型

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

浮点数

浮点类型：用来表示带小数点的数值，在 Python 中，没有 Double 类型，统一使用 float 类型表示。
复数类型：一般在数学和物理学中有广泛的应用，例如在电路分析、信号处理和量子力学中，在此了解即可

整数类型

def int_info():
n = 1
print(n)
print(type(n)) # <class ‘int’>

n = 987089479439434384938493893843489384343843434343434
print(n)
n = n + 1
print(n)
print(type(n))  # <class 'int'>

浮点型 float

def float_info():
n = 1.0
print(n)
print(type(n))

#f复数类型
def complex_info():
n = 4 + 3j
print(n)
print(type(n))

int_info()

float_info()

complex_info()

布尔类型

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

布尔类型只有两个值，即 True 和 False 表示真和假，在 Python 中，布尔类型通常用于判断逻辑关系和状态标记。

条件判断

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。
空序列，包括字符串、空元组、空列表、空字典。

def bool_info() → object:
print(1 > 2) # false
print(1 < 2) # True
# 标记对象
isSelect = True
isExist = False

isExist = True

print(isSelect)

if not {}:
print(“No”)
else:
print(“Yes”)

bool_info()

类型转换

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

自动转换

自动转换也称为隐式类型转换，程序在执行过程中自动完成，将数据精度低转换为数据精度高的类型。
有些时候，在对不同类型的数据进行运算时，Python 会自动将它们转成同样的类型，然后再计算结果。

强制转换

强制转换也称为显式类型转换，需要在代码中使用类型函数来转换。
比如通过 input() 函数获取的数字，实际为一个数字字符串，如果需要进行计算，需要将其转换成真正的数字才能进行数据计算。
如果我们不进行类型转换，那么可能会导致程序出现错误或者无法正常运行

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): 将一个整数转换为一个字符，虽然结果是一个字符，但其本质依然是一个字符串类型。

类型转换(自动类型转（隐式类型转换）、强制类型转换（显式类型转换））

隐式转换

import abc

def type_trans():
result = 10 + 3.14 # 自动将整型转变为浮点型进行计算，自从由精度低的向精度高的转化
print(result) # 13.14
print(type(result)) # <class ‘float’>

result = True + 1  # true作为1 进行计算为 2
print(result)
print(type(result))  # <class 'int'>

强制类型转换

data = input("请输入一个数字: ")

result = int(data) + 10 # 将data 强制转换成int 进行计算

print(result)

print(type(result))

print(float(1)) # 1.0
print(int(3.14)) # 3
print(int(3.74)) # 3
print(complex(3.74)) # (3.74+0j)
print(bool(3.74)) # True
print(bool()) # False
print(str(3.74)) # 3.74
print(chr(48)) # 0
print(type(chr(48))) # <class ‘str’>
print(chr(65)) # A
print(chr(97)) # a

type_trans()
如果在强制类型转换时，传递的转换数据不合法导致无法转换，那么将会抛出异常。

x = int("霍格沃兹")

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

运算符

Python 语言常用运算符如下:

算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
成员运算符
身份运算符
运算符优先级

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

单目运算符
双目运算符
三目运算符

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

算术运算符

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

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

def clac_info():
# 加法 +
print(1 + 2)
print(10 + 200)
print(“Hello” + “World”)
print(“Hello” + str(1))

# 减法 -
print(20 - 19)
print(10 - 12)

# 乘法 *
print(2 * 3)
print(100 * 20)
print("Hello" * 3)
print(3 * "Hello")

# 除法 /

print(8 / 2)
print(9 / 2)
#  print(1 /0)

# 取模 （求余）

print(8 % 2)
print(9 % 2)
n = int(input("请输入任意数字:"))
print(n % 10 + 1)

# 整除 //

print(8 // 2)
print(9 // 2)
print(7 // 2)

# 幂运算符 **
print(2 ** 10)
print(2 ** 11)

clac_info()

赋值运算符

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

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

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

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

赋值运算符

def ass_info():
# 赋值运算符 =
num = 2 + 3 * 5
print(num)
# 同时定义多个变量
a, b, c, d = 1, 2, 3333, 44
print(a, b, c, d)

复合赋值运算符

加法赋值运算符（+=）

num = 10
num += 20  # num=num +20
print(num)

减法赋值运算符（-=）

num = 10
num -= 20  # num=num -20
print(num)

幂赋值运算符（**=）

num = 10
num **= 20
print(num)

取整除赋值运算符（//=）

num = 10
num //= 20  # num=num //20
print(num)

乘法赋值运算符（*=）

num = 2
num *= 3+4   # num = 2*（3 +4） 算术和赋值运算符混合时，算术运算符优先级高于赋值运算符
print(num)

除法赋值运算符（/=)

num= 9
num /= 20
print(num)

ass_info()

关系运算符

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

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

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

关系比较运算符

def rela_info():
# 等于 ==
print(1 == 1) # True
print(1 == 2) # False
print(1 == “1”) # False
print(1 == “2”) # False
print(“abc” == “abc”) # True
print(“abc” == “ABC”) # False

# 不等于 !=
print(1 != 1)  # False
print(1 != 2)  # True
print(1 != "1")  # True
print(1 != "2")  # True
print("abc" != "abc")  # False
print("abc" != "ABC")  # True

# 大于 >
print(1 > 2)  # False
print(1 > 1)  # False
print(1 > 0)  # True
print("a" > "A")  # True
print("abc" > "ABC")  # True
print("aBC" > " Abed ")  # True
# print(1 > "a")     # True   不支持数值和字符串比较

# 大于等于 >=
print(1 >= 1)
print(1 >= 0)
print(1 >= 2)
# 小于
print(1 < 1)
print(1 < 2)

# 小于等于 <=
print(1 <= 1)
print(1 <= 0)
print(1 <= 2)

rela_info()

逻辑运算符

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

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

运算符	逻辑表达式	描述
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。

短路特性

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

非短路操作

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

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

短路操作

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

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

逻辑运算符

def logi_info():
# 逻辑与and
print( 1 > 0 and 2 > 0)
print(1 < 0 and 2 > 0)
print(1 > 0 and 2 < 0)
print(True and 5)

# 逻辑或 or
print(1 >0 or 2 >1)
print(1 <0 or 2 >1)
print(1 <0 or 2 <1)

print(4 or False)
print(False or "H")

# 逻辑非not
print(not True)
print(not False)

# 非短路操作
result = True and print("Python1")
print(result)
result = False and print("Python1")
print(result)

# 短路操作
result = False and 1/0
print(result)
result = 1 or 1 /0     # 只有一个为真，后面不会执行
print(result)

logi_info()

成员运算符

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

如下表所示：

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

身份运算符

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

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

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

身份运算符如下表所示：

运算符	描述
is	is 是判断两个标识符是不是引用自一个对象
is not	is not 是判断两个标识符是不是引用自不同对象
目的：提高性能和减少内存开销
整数池（Integer Pool）：在程序运行时预先创建一些整数对象，并将其保存在整数池中。可以重用存在的对象，在一定程度上减少内存开销
字符串池（String pool）:对于较短的字符串，会使用字符串池进行优化，是个缓存区，保存着所有共享相同内容的字符串对象。当创建的字符串对象时，会先检查是否已经存在相同的字符串对象，存在则直接重用已有的对象，避免重复创建新的
在某些情况下，字面量相同的两个对象，实际并不是同一个对象，此时如果需要区分对象的话，就需要使用身份运算符。

身份运算符

def ident_info():
# s1 = “hello”
# s2 = “hello”
# print(“s1:”,id(s1))
# print(“s2:”,id(s2))
# print(s1 == s2)
# print(s1 is s2)
s1 = “hello , world!!!” * 1000
s2 = “hello, world!!!” * 1000
print(“s1:”, id(s1))
print(“s2:”, id(s2))
print(s1 == s2)
print(s1 is s2)

内存地址
数据类型
值
而 is 与 == 都作为常用的判断语句进行使用：
==运算符：只比较两个对象的值，相同返回True,不同返回False
is 运算符：比较两个对象的id,相同返回True,不同返回False

三目运算符
三目运算符也称为三元运算符，运算符扎使用时，需要有三个操作数参与计算
if-else分支语句的简化单行模式
语法格式： [on_true] if [expression] else [on_false]
on_true :条件为真时的结果

字符串
由引号包裹的任意字符组成的不可变序列，用于表示文本类型数据
可以通过单引号或双引号或三引号来定义，用于表示文本信息
name=‘Alice’
message=“Hello,word!”
sql_string =“”“select * from user where name=‘tom’ “””

下标索引
下标指从0开始数字

字符串的定义

def string_info():
s1 = ‘hello’
print(‘hello’)
print(s1)
print(type(s1))
# 使用双引号定义字符串
s2 = “你好 python!”
print(s2)
print(type(s2))
# 使用三引号定义字符串
s3 = ‘select * from user where name=“Tom”’
s4 = “”“select * from user where name=“Tom”;”“”
s5 = ‘’‘select * from user where name=‘Tom’’‘’’
s6 = “”“select * from user where name=‘Tom’;”“”
print(s3, s4, s5, s6)
print(type(s3), type(s4), type(s5), type(s6))

print("hello\nworld")  # 换行符
s7= '''select * from user where name='Tom\''''  # 转义字符
print(s7)
path1 = "c:\\python\\bin\\python.exe"
path2 = "c:/python/bin/python.exe"
print(path1,path2)

s= "HelloWorld"
# 字符串下标
print(s[0])  # H
print(s[5])  # W
print(s[9])  # d

string_info()

字符串操作

统计查找替换类

len()用于获取参数字符串的字符字数,函数格式：len(obj)

count（）返回str在string里面出现的次数，如果start或者end 指定则返回指定范围内str出现的次数
格式： count(str,start,end)

index（）检测sub是否包含在string中，如果start 和end指定范围，则检查是否包含在指定范围内，如果返回开始的索引值，否则抛出一个异常格式：index(sub，start,end)
rindex（）作用同 index()，查找子串时从右侧查找，若查找不到抛出一个异常格式：rindex(sub,start,end)
find()检测sub是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围内。如果是返回开始的索引值，否则返回-1格式：find(sub,start,end)
rfind()作用同find，查找子串时从右侧查找，若查找不到会抛出一个异常，格式：rfind(sub,start,end)
replace()把string中old替换成new,如果max指定，则替换不超过max次，格式：replace(old,new,max)

字符串判断类

startwith()检查字符串是否以prefix开头，是则返回True,否则返回False,如果start和end指定值，则在指定范围内检查，格式：startwith(prefix,start,end)

endwith()检查字符串是否是以suffix开头，否则返回False。如果start和end指定值，则在指定范围内检查，格式：endwith(suffix,start,end)

isalpha()如果string至少有一个字符并且所有字符串都是字母返回True,否则返回false格式：isalpha()

isdigit() 如果 string 只包含数字则返回 True 否则返回 False.

格式：isdigit()

示例：

```python
print("123".isdigit())
print("123abc".isdigit())
print("abc123".isdigit())
print("".isdigit())


* `isalnum()` 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

格式：`isalnum()`

示例：

print("abc".isalnum())
print("ABC".isalnum())
print("ABCabc".isalnum())
print("123".isalnum())
print("abc123".isalnum())
print("123abc".isalnum())
print("a b".isalnum())
print("a@".isalnum())
print("".isalnum())


* `isspace()` 如果 string 中只包含空格，则返回 True，否则返回 False.

格式：`isspace()`

示例：

print(" ".isspace())
print("    ".isspace()) # tab键，由4个空白组成
print("\t".isspace())
print("\n".isspace())
print("\r".isspace())
print("".isspace())
print(" a".isspace())
print("1 ".isspace())


* `isupper()` 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

格式：`isupper()`

示例：

print("ABC".isupper())
print("ABC123".isupper())
print("123ABC".isupper())
print("A!@#B".isupper())
print("abc".isupper())
print("abC".isupper())
print("abc123".isupper())
print("Abc!@#".isupper())
print("123".isupper())
print("".isupper())
print(" ".isupper())


* `islower()` 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

格式：`islower()`

示例：

print("abc".islower())
print("abc123".islower())
print("ABC".islower())
print("abC".islower())
print("Abc!@#".islower())
print("123".islower())
print("".islower())
print(" ".islower())


* `istitle()` 如果 string 是标题化的（所有单词首字符是大写）则返回 True，否则返回 False

格式：`istitle()`

示例：

print("Username".istitle())
print("User Name".istitle())
print("User_Name".istitle())
print("User.Name".istitle())
print("User+Name".istitle())
print("username".istitle())
print("UserName".istitle())
print("user name".istitle())
print("User name".istitle())

### 字符串转换类

* `capitalize()` 把字符串的第一个字符大写

格式：`capitalize()`

示例：

print("username".capitalize())
print("Username".capitalize())
print("userNAME".capitalize())
print("this is username".capitalize())


* `title()` 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写

格式：`title()`

示例：

print("this is username".title())
print("THIS IS USERNAME".title())
print("tHIS IS username".title())


* `upper()` 转换 string 中的小写字母为大写

格式：`upper()`

示例：

print("abc".upper())
print("ABC".upper())
print("abCd".upper())
print("abc123".upper())
print("abc123ABC".upper())


* `lower()` 转换 string 中的小写字母为小写

格式：`lower()`

示例：

print("abc".lower())
print("ABC".lower())
print("abCd".lower())
print("abc123".lower())
print("abc123ABC".lower())


### 字符串对齐类

* `center()` 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串，如果指定fillchar参数，则使用指定字符填充，fillchar参数长度只能为1

格式：`center(width, fillchar)`

示例：

print("|"+"hogworts".center(20) + "|")
print("|"+"hogworts".center(5) + "|")
print("|"+"hogworts".center(20, "-") + "|")


* `ljust()` 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串，如果指定fillchar参数，则使用指定字符填充，fillchar参数长度只能为1

格式：`ljust(width, fillchar)`

示例：

print("|"+"hogworts".ljust(20) + "|")
print("|"+"hogworts".ljust(5) + "|")
print("|"+"hogworts".ljust(20, "-") + "|")


* `rjust()` 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串，如果指定fillchar参数，则使用指定字符填充，fillchar参数长度只能为1

格式：`ljust(width, fillchar)`

示例：

print("|"+"hogworts".rjust(20) + "|")
print("|"+"hogworts".rjust(5) + "|")
print("|"+"hogworts".rjust(20, "-") + "|")


### 字符串去除空白类

* `strip()` 删除 string 左右两侧的空白字符, 如果指定chars参数，则删除左右两侧指定的字符

格式：`strip(chars)`

示例：

print("|" + "  hogworts  " + "|")
print("|" + "  hogworts  ".strip() + "|")
print("|" + "  hogworts".strip() + "|")
print("|" + "hogworts  ".strip() + "|")
print("|" + "  h o g w o r t s  ".strip() + "|")
print("|" + "bachogwortsabc".strip("cba") + "|")


* `lstrip()` 删除 string 左边的空白字符, 如果指定chars参数，则删除左两侧指定的字符

格式：`lstrip(chars)`

示例：

print("|" + "  hogworts  " + "|")
print("|" + "  hogworts  ".lstrip() + "|")
print("|" + "  hogworts".lstrip() + "|")
print("|" + "hogworts  ".lstrip() + "|")
print("|" + "  h o g w o r t s  ".lstrip() + "|")
print("|" + "bachogwortsabc".lstrip("cba") + "|")


* `rstrip()` 删除 string 左边的空白字符, 如果指定chars参数，则删除右两侧指定的字符

格式：`lstrip(chars)`

示例：

print("|" + "  hogworts  " + "|")
print("|" + "  hogworts  ".rstrip() + "|")
print("|" + "  hogworts".rstrip() + "|")
print("|" + "hogworts  ".rstrip() + "|")
print("|" + "  h o g w o r t s  ".rstrip() + "|")
print("|" + "bachogwortsabc".rstrip("cba") + "|")


### 字符串分割类

* `split()` 以 sep 为分隔符分割 string，如果指定 maxsplit 参数，则仅分割 maxsplit次

格式：`split(sep, maxsplit)`

示例：

print("a-b-c-d".split("-"))
print("a-b-c-d".split("-", 2))
print("a--b-c-d".split("-"))
print("a-+b-c-d".split("-+"))
print("a b\tc\nd\re".split())
print("a b c d e".split(" ", 3))


* `splitlines()` 使用换行符`\n`分割 string，如果指定 `keepends` 参数，则结果中会保留`\n`符号

格式：`splitlines(keepends)`

示例：

print("a\nb\nc".splitlines())
print("a\nb\nc".splitlines(True))


* `partition()` 从 sep 出现的第一个位置起,把 string 分成一个3元素的元组 (string_pre_sep,sep,string_post_sep),如果 string 中不包含 sep 则 string_pre_str == string，其余元素为空字符串

格式：`parttion(sep)`

示例：

print("This is Hogworts".partition("is"))
print("This is Hogworts".partition("iss"))


* `rpartition()` 从右向左 sep 出现的第一个位置起,把 string 分成一个3元素的元组 (string_pre_sep,sep,string_post_sep),如果 string 中不包含 sep 则 string_post_str == string，其余元素为空字符串

格式：`rparttion(sep)`

示例：

print("This is Hogworts".rpartition("is"))
print("This is Hogworts".rpartition("iss"))


### 字符串连接类

* `+号` 将两个字符串连接生成一个新字符串, `+` 号两侧必须都是字符串

格式：`str1 + str2`

示例：

print("Hello" + "World")
print("Hello" + "123")
print("Hello" + 123)


* `*号` 将字符串重复N次后生成一个新字符串

格式：`str * n`

示例：

print("*"* 10)
print("hello"* 10)


* `join()` 使用 string 连接可迭代对象中的所有元素，可迭代对象参数中的所有元素必须是字符串

格式：`join(iterable)`

示例：

print("".join(("a","b","c")))
print("-".join(("a","b","c")))
print("->".join(("a","b","c")))
print("->".join(["a","b","c"]))
print("->".join({"a","b","c"}))
print("->".join({"a":"A","b":"B","c":"C"}))


### 编码解码类

* `encode()` 使用 encoding 指定的字符集，对 string 进行编码，转换成二进制字符串

格式：`encode(encoding)`

示例：

print("abc123".encode("gbk"))
print("你好".encode("gbk"))

print("abc123".encode("utf-8"))
print("你好".encode("u8"))


* `decode()` 使用 encoding 指定的字符集，对 string 进行解码，转换成字符串对象， string必须是二进制字符串

格式：`decode(encoding)`

示例：

s1 = b'\xc4\xe3\xba\xc3'
s2 = b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(s1.decode("gbk"))
print(s2.decode("utf-8"))

# print(s1.decode("u8"))
# print(s2.decode("gbk"))


### 切片操作

对字符串按指定的范围进行截取，得到一个子字符串，指定范围时，起始下标必须小于结束下标，且子字符串不包含结束下标

格式：`str[start: end: step]`

示例：

s = "abcdefg"

# 普通切片
print(s[0: 2])
# 省略范围
print(s[0:])
print(s[: 2])
print(s[:])
# 指定步长
print(s[::1])
print(s[::2])
# 负下标
print(s[-3: -1])
# 负步长
print(s[-1: -3: -1])
# 逆序
print(s[::-1])

字符串格式化是一种将变量或值插入到字符串中的过程，以创建具有动态内容的字符串。

在Python中，我们可以使用format()方法和f-string（格式化字符串字面值）来进行字符串格式化。

### format()方法

format()方法是一种传统的字符串格式化方法。它使用占位符 {} 来表示要插入的变量或值，并通过传递参数来替换这些占位符。

#### 基本用法

name = “Alice”
age = 25
message = “My name is {}, and I am {} years old.”.format(name, age)
print(message)

输出：My name is Alice, and I am 25 years old.


在上述示例中，使用 `{}` 占位符表示要插入的变量或值。在调用 `format()` 方法时，通过参数的顺序将相应的值传递给占位符，从而替换字符串中的占位符部分。最终生成的字符串是根据传入的值进行了相应的替换。

#### 位置参数

`format()` 方法支持使用位置参数来指定变量或值的插入顺序。可以在占位符 `{}` 中使用索引号来指定要插入的参数的位置。

name = “Alice”
age = 25
message = “My name is {0}, and I am {1} years old.”.format(name, age)
print(message)

输出：My name is Alice, and I am 25 years old.


在上述示例中，`{0}` 表示第一个参数 `name` 要插入的位置，`{1}` 表示第二个参数 `age` 要插入的位置。

通过在 `format()` 方法中按照顺序传递相应的参数，就可以根据索引号将值插入到指定的位置。最终生成的字符串是根据传入的值和索引号进行了相应的替换。

#### 关键字参数

format()方法还支持使用关键字参数来指定变量或值的插入位置。

name = “Alice”
age = 25
message = “My name is {name}, and I am {age} years old.”.format(name=name, age=age)
print(message)

输出：My name is Alice, and I am 25 years old.


在上述示例中，`{name}` 和 `{age}` 分别表示关键字参数 `name` 和 `age` 要插入的位置。通过在 `format()` 方法中使用关键字参数，可以根据参数名将值插入到相应的位置。最终生成的字符串是根据传入的值和参数名进行了相应的替换。

#### 格式化选项

在 `format()` 方法中，还可以使用格式化选项来控制插入值的格式，如字段宽度、对齐方式、小数点精度等。

pi = 3.141592653589793
formatted_pi = “The value of pi is approximately {:.2f}”.format(pi)
print(formatted_pi)

输出：The value of pi is approximately 3.14


在上述示例中，{:.2f} 是一个格式化选项，它指定了插入的值应该被格式化为带有两位小数的浮点数。通过在冒号后面指定格式化选项，可以控制插入值的显示方式。在这个例子中，值 pi 被格式化为带有两位小数的浮点数，最终生成的字符串为 "The value of pi is approximately 3.14"。

字符串对齐

print(“The value is ljust: |{:5}|”.format(“abc”))
print(“The value is rjust: |{:<5}|”.format(“abc”))
print(“The value is rjust: |{:>5}|”.format(“abc”))

数字对齐

print(“The value is rjust: |{:5}|”.format(11))
print(“The value is rjust: |{:<5}|”.format(11))
print(“The value is rjust: |{:>5}|”.format(11))


### f-string字符串

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

#### 基本用法

name = “Alice”
age = 25
message = f"My name is {name}, and I am {age} years old."
print(message)

输出：My name is Alice, and I am 25 years old.


在上述示例中，字符串前面加上 f 前缀表示这是一个 f-string。在字符串中使用花括号 {} 来插入变量或表达式，它们会在运行时被替换为相应的值。在花括号内部，可以直接使用变量名或表达式，它们会被自动计算并插入到字符串中。最终生成的字符串根据插入的变量或表达式而动态变化。

#### 对齐方式

f-string 的格式化选项方式使用同 format()函数一致

字符串对齐

print(f"The value is ljust: |{‘abc’:5}|“)
print(f"The value is ljust: |{‘abc’:<5}|”)
print(f"The value is rjust: |{‘abc’:>5}|")

数字对齐

print(f"The value is rjust: |{11:5}|“)
print(f"The value is rjust: |{11:>5}|”)
print(f"The value is ljust: |{11:<5}|")

小数保留

print(f"The value is rjust: |{3.1415926:5.2f}|")


#### 表达式和函数调用

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

name = “Alice”
age = 25
greeting = f"{‘Hello’ if age < 30 else ‘Hi’} {name.upper()}"
print(greeting)

输出：HELLO ALICE


在上述示例中，使用了一个条件表达式 `{'Hello' if age < 30 else 'Hi'}` 来根据年龄的大小选择不同的问候词。如果年龄小于 `30`，那么使用 `Hello`；否则使用 `Hi`。同时，在插入变量 `name` 后，使用了 `name.upper()` 函数调用来将名称转换为大写字母。

f-string 允许在花括号 `{}` 内部使用任意的表达式和函数调用，这些表达式和函数会在运行时进行求值，并将结果插入到字符串中。这使得我们能够生成更加动态和灵活的字符串内容。

### 字符串格式化的更多用法

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

* 设置字段宽度和对齐方式
* 控制字段宽度和对齐方式
* 设置小数点精度和浮点数格式化
* 格式化日期和时间
* 格式化数字的千位分隔符
* 使用填充字符进行对齐
* 格式化二进制、十六进制和其他进制数值
* 详细的格式化选项可以参考[Python官方文档](https://docs.python.org/zh-cn/3.10/library/string.html#)

### 总结

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

* 元组是一种数据类型，在Python中用于存储多个元素。元组可以容纳多个值，但它们有一些重要的特点。

* 元组是有序的数据结构，这意味着元组中的元素按照它们的顺序存储，并且可以通过索引进行访问和引用。

* 元组是不可变的，一旦定义后，元组中的数据不可以进行添加，修改和删除等操作。

* 元组是异构的，可以包含不同类型的元素，例如整数、浮点数、字符串等。这使得元组成为一种有效的数据结构，用于存储多种不同类型的元素。

### 元组的定义

#### 元组的字面量定义

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

t1 = (1, 2, “hello”, True)
t2 = (1, )
t3 = ()


#### 元组的构造方法定义

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

t1 = tuple(“abc”)
t2 = tuple((1,2,3))
t3 = tuple([1,2,3])


### 元组中元素的引用

元组同字符串一样，也可以使用下标形式引用元组中的元素。并且，下标不能超过元组的元素个数减1，否则会抛出下标越界错误。

t = (1,2,3,4,5)
print(t[0])
print(t[3])
print(t[5])


### 元组的切片操作

元组的切片操作同字符串一致

t = (1,2,3,4,5)
print(t[0:3])
print(t[:3])
print(t[3:])
print(t[:])
print(t[::-1])


### 元组的特点

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

t1 = (1, 2, 3)
t1[0] = 10 # 错误！元组不可修改


元组的不可变性使其在某些情况下很有用，例如在需要确保数据的完整性和不变性的场景中。它们也可以用作字典的键或作为函数的参数和返回值。

### 元组的应用场景

* 存储一组不可变的数据：由于元组的不可变性，它们非常适合存储一组不会发生变化的数据，如常量、配置信息等。您可以使用元组来存储相关的值，以确保数据的完整性和不变性。
* 作为字典的键值对：元组可以作为字典的键值对使用，因为元组是不可变的，可以保证字典中的键的稳定性。相比列表，元组更适合作为字典的键，因为字典的键必须是不可变的。
* 函数返回多个值：函数可以使用元组作为返回值，以便一次性返回多个相关的值。通过返回元组，函数可以将多个数据打包在一起，并且调用函数时可以方便地解包元组，获取其中的各个值。

### 元组的常用方法

由于元组的不可变特性，所以元组提供的操作方法非常少。

* `len()` 获取元组元素个数 格式：`len(t)`

t = (1,2,3,4,5)
print(len(t))


* `count()` 统计元组中参数 value 指定值的个数。 格式：`count(value)`

t = (1,2,3,4,5,1,2,3,1,2,3,3,3,3)
print(t.count(3))


* `index()` 在元组中查找 value 第一次出现的下标。如果指定了范围，则仅在指定范围内查找，如果查找的数据在元组中不存在，会抛出一个错误。 格式：`index(value, start,stop)`

t = (1,2,3,4,5,1,2,3)
print(t.index(3))


## 列表操作

### 获取列表元素个数

格式：`len(l)`

l = [1,2,3,4,5]
length = len(l)


### 统计查找操作

* `count(value)` 在列表中统计参数 value 出现的次数

l = [1,2,3,4,5,1,2,3,3]
print(l.count(3))


* `index(value, start, stop)` 在列表中查找参数 value 第一次出现的下标位置，如果给定范围则只在范围内查找，如果查找目标不存在则抛出错误。

l = [1,2,3,4,5,1,2,3,3]
print(l.index(3))
print(l.index(3,5,10))


### 增加元素

* `append(value)` 向列表最后追加元素

l =
l.append(1)
print(l)
l.append(1)
print(l)
l.append(2)
print(l)


* `extend(iterable)` 将一个可迭代对象的元素依次添加到列表最后

l1 = [1,2,3]
l2 = [“a”,“b”,“c”]

l1.append(l2)
print(l1)
l1.extend(l2)
print(l1)
l1.extend(“456”)
print(l1)
l1.extend((“A”,“B”,“C”))
print(l1)


* `insert(index, value)` 向列表指定下标位置插入一个元素，原有元素依次后移，如果指定下标超过元素个数，则插入到列表最后。

l = [1,2,3,4,5]

l.insert(0, “A”)
print(l)
l.insert(3, “B”)
print(l)
l.insert(10, “C”)
print(l)
l.insert(9, “D”)
print(l)


### 删除元素

* `del` 可以使用 del 关键字结合索引来删除指定位置的元素。如果指定的下标不存在则抛出一个错误。

l = [1,2,3,4,5,1,2,3]
del l[0]
print(l)
del l[10]


* `remove(value)` 在列表中删除第一个指定的数据，如果删除的数据不存在则抛出错误

l = [1,2,3,4,5,1,2,3]
l.remove(3)
print(l)
l.remove(33)


* `pop(index)` 从列表中取出并删除指定下标位置的元素，默认取出并删除最后一个元素，如果指定下标不存在，则会抛出一个错误。

l = [1,2,3,4,5,1,2,3]
print(l.pop())
print(l)
print(l.pop(3))
print(l)
print(l.pop(10))


* `clear()` 清空列表

l = [1,2,3,4,5,1,2,3]
l.clear()
print(l)


### 列表排序

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

l = [“a”,“abc”,“ab”,“A”]
l.sort()
print(l)
l = [“a”,“abc”,“ab”,“A”]
l.sort(reverse=True)
print(l)

# 元组和列表的区别

## 元组和列表的区别

### 相同点

* 元组和列表在Python中，都是有序的，可迭代的数据结构。
* 元组和列表都是异构的，都可以存放不同数据类型的元素。

### 不同点

* 元组是不可变的，不可以进行增删改操作，一旦定义，无法修改
* 列表是可变的，可以对列表中的元素进行增删改操作，空列表有实际意义。

### 内存占用

由于元组与列表内部的实现机制不同，在相同元素和个数的情况下，元组占用内存空间更小。

from sys import getsizeof
t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(getsizeof(t))
print(getsizeof(l))


### 总结对比

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

## 字典操作

### 字典数据获取类操作

* `keys()` 用来获取字典中所有的 key, 保存到一个列表中，并以 `dict_keys`类型返回

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
ks = stu.keys()
print(ks)


* `values()` 用来获取字典中所有的value, 保存到一个列表中，并以 `dict_values` 类型返回

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
ks = stu.values()
print(ks)


* `items()` 用来获取字典中所有的键值对，每一个元素键值对都以一个元组保存，将所有元素元组保存到一个列表中，并以 `dict_items` 类型返回

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
ks = stu.items()
print(ks)


* `get(key, default)` 用来获取key对应的值，如果指定的key不存在，则返回默认值。字典可以使用 `字典对象[key]`的形式获取键值对，但是该方法如果指定的 key 不存在，程序会抛出一个错误。此时可以使用`get()`替代该取值方法

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}

print(stu[“name”])

print(stu[“hobby”])

print(stu.get(“name”))
print(stu.get(“hobby”))
print(stu.get(“hobby”,“无数据”))


### 字典添加更新类操作

* `setdefault(key,default)` 给一个不存在的key添加一个默认值并将该键值对保存到字典中。在一些场景下，字典的key存在，但是该key却没有对应的值，此时，就可以使用该方法，为当前的key添加一个默认值。比如服务端要保存客户端发起请求时携带的请求头中的信息。

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}

stu.setdefault(“hobby1”)
print(stu)
stu.setdefault(“hobby2”, “无”)
print(stu)


* `fromkeys(keys,val)` 用于创建一个新字典，以序列 keys 中元素做字典的键，value 为字典所有键对应的初始值,默认为`None`。该方法是一个静态方法，需要使用字典类型名 `dict` 调用。 该方法如果给给定 keys 参数，则所有的key对应值都为默认值 `None`,如果给定 val值，则所有key对应的值为 val。

ks = (“name”, “age”, “gender”)
s1 = dict.fromkeys(ks)
print(s1)

s2 = dict.fromkeys(ks,“无”)
print(s2)


* `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)


### 字典删除类操作

* `popitem()` 用来获取并删除字典中的最后一个键值对，返回一个元组，如果字典为空时，则抛出一个错误

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
v = stu.popitem()
print(v)
print(stu)

v = stu.popitem()
print(v)
print(stu)

print({}.popitem())


* `pop(key)` 用于获取并删除字典中指定key对应的键值对。如果指定的key不存在，则抛出错误

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}
v = stu.pop(“name”)
print(v)
print(stu)


* `clear()` 清空字典中所有的键值对元素

stu = {‘name’: ‘Tom’, ‘age’: 23, ‘gender’: ‘male’, ‘address’: ‘BeiJing’}

print(stu)
stu.clear()
print(stu)


### 集合

* 集合是一种数据类型，用于存储多个元素，并确保元素的唯一性。
* 集合中的元素是无序的，不可通过索引或切片进行访问。
* 集合的主要特点是元素不重复，相同的元素在集合中只会出现一次。
* 我们可以使用大括号 {} 或 set() 函数来定义和创建集合。
* 集合提供了各种集合运算，如并集（两个集合中的所有元素）、交集（两个集合中共有的元素）、差集（第一个集合中存在而第二个集合中不存在的元素）等操作。

### 集合的创建

不能使用 `{}` 创建一个空集合，因为此种方式创建的类型为字典。

不能使用花括号 {} 来定义一个空集合

s1 = set()
s2 = {}
print(type(s1))
print(type(s2))

使用花括号 {}，在内部添加元素，用逗号 , 分隔

my_set = {1, 2, 3, 4, 5}

使用内置函数 set() 创建集合

my_set = set([1, 2, 3, 4, 5])

集合元素具有唯一性

s = {1,1,1,2,3,4,5,6,6,6,6,6,6,6}
print(s)


集合常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。

由于集合不支持下标操作，所以不支持常规方式的获取和修改。

## 集合操作

### 添加操作

* `add(ele)` 向集合中添加一个元素,如果元素则不产生任何影响

s = {1, 2, 3}

s.add(4)
print(s)
s.add(“Hello”)
s.add(“Hello”)
print(s)


* `update(others)` 更新集合，添加来自 others 中的所有元素,others是一个可迭代对象，如果数据在集合中存在则不更新。

s = {1, 2, 3}

s.update((4,5,6))
print(s)
s.update([5,6,7])
print(s)
s.update({6,7,8,9})
print(s)


### 删除操作

* `pop()` 从集合中移除并返回任意一个元素，如果集合为空，则抛出错误

s = {1, 2, 3}

print(s.pop())
print(s)
print(s.pop())
print(s)
print(s.pop())
print(s)
print(s.pop())


* `remove(elem)` 从集合中移除元素 elem。 如果 elem 不存在于集合中则抛出错误。

s = {1, 2, 3}

print(s.remove(1))
print(s)
print(s.remove(3))
print(s)
print(s.remove(5))


* `discard(elem)` 如果元素 elem 存在于集合中则将其移除，如果elem不存在，则什么也不做

s = {1, 2, 3}

s.discard(1)
print(s)
s.discard(3)
print(s)
s.discard(5)


* `clear()` 清空集合

s = {1, 2, 3}
s.clear()
print(s)


### 集合数据操作

#### 判断两个集合是否不相交

* `isdisjoint(other)` 如果集合中没有与 other 共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合。

s = {1, 2, 3}

print(s.isdisjoint({4, 5, 6}))
print(s.isdisjoint({3, 4, 5}))


#### 判断集合是否是另一个集合的子集

* `issubset(other)` 检测是否集合中的每个元素都在 other 之中。

s = {1, 2, 3}

判断 s 是否为 other参数的子集

print(s.issubset({1, 2, 3}))
print(s.issubset({1, 2, 3, 4}))
print(s.issubset({3, 4, 5}))
print(“*” * 10)

也可以通过运算符 <= 直接判断

print(s <= {1, 2, 3})
print(s <= {1, 2, 3, 4})
print(s <= {3, 4, 5})
print(“*” * 10)

判断是否为真子集

print(s < {1, 2, 3})
print(s < {1, 2, 3, 4})
print(s < {3, 4, 5})


#### 判断集合是否是另一个集合的超集

* `issuperset(other)` 检测是否 other 中的每个元素都在集合之中。

s = {1, 2, 3, 4}

判断 s 是否为 other参数的超集

print(s.issuperset({1, 2, 3}))
print(s.issuperset({1, 2, 3, 4}))
print(s.issuperset({3, 4, 5}))
print(“*” * 10)

也可以通过运算符 >= 直接判断

print(s >= {1, 2, 3})
print(s >= {1, 2, 3, 4})
print(s >= {3, 4, 5})
print(“*” * 10)

判断是否为真超集

print(s > {1, 2, 3})
print(s > {1, 2, 3, 4})
print(s > {3, 4, 5})


#### 并集

* `union(*other)` 返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素,other可以指定多个集合。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.union(s2))
print(s1.union(s2,s3))

也可以使用 | 进行集合并集运算

print(s1 | s2)
print(s1 | s2 | s3)


#### 交集

* `intersection(*others)` 返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.intersection(s2))
print(s1.intersection(s2, s3))
print(s1.intersection(s3))
print(“*” * 10)

也可以使用 & 进行集合交集运算

print(s1 & s2)
print(s1 & s2 & s3)
print(s1 & s3)


#### 差集

* `difference(*others)` 返回一个新集合，包含原集合中在 others 指定的其他集合中不存在的元素。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.difference(s2))
print(s1.difference(s2, s3))
print(s1.difference(s3))
print(“*” * 10)

也可以使用 - 进行集合差集运算

print(s1 - s2)
print(s1 - s2 - s3)
print(s1 - s3)


#### 对称差集

* `symmetric_difference(other)` 返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s3 = {5, 6, 7, 8}
print(s1.symmetric_difference(s2))
print(s1.symmetric_difference(s3))
print(“*” * 10)

也可以使用 ^ 进行集合对称差集运算

print(s1 ^ s2)
print(s1 ^ s3)


## 深拷贝与浅拷贝

### 什么是拷贝

* 拷贝是指使用一个已存在一个对象，生成一个新的对象，两个对象在内存中具有独立的存储空间。

* 浅拷贝是指是创建一个新的对象时，只拷贝内容是原始对象的引用，而不是创建原始对象的副本数据。

* 深拷贝是指创建一个新的对象，并递归地复制原始对象及其所有嵌套对象的内容，而不仅仅是复制它们的引用。

* 浅拷贝不具有数据独立性，对象的 `copy()` 方法，`copy` 模块的`copy()` 方法，工厂方法，切片等方式得到的都是浅拷贝对象。

* 深拷贝具有数据独立性，使用 `copy` 模块中的 `deepcopy()` 方法实现深拷贝。

* 程序的大部分场景都使用浅拷贝。

* 浅拷贝，深拷贝特指容器类型保存的复杂结构，对于基本类型的数据，都是引用指向（不在缓存池中的字符串对像除外）。

* 类似公共排序方法 `sorted()` 实现就可以使用深拷贝，因为该方法返回一个排序后的新列表，该列表可能在程序其它位置被修改，避免影响原列表，深拷贝更适合。

### 浅拷贝

import copy

原始数据

originData = [[1,2],{“name”:“Tom”, “chars”:[“A”,“B”]}]

使用对象的copy()方法得到浅拷贝对象

copyData1 = originData.copy()

使用工厂方法获取浅拷贝对象

copyData2 = list(originData)

使用切片方式获取浅拷贝对象

copyData3 = originData[:]

使用 copy模块中的copy方法获取浅拷贝对象

copyData4 = copy.copy(originData)

拷贝成功的验证，内容相同，地址不同

查看所有对象内容

print(originData)
print(copyData1)
print(copyData2)
print(copyData3)
print(copyData4)

查看所有对象的址,

print(id(originData))
print(id(copyData1))
print(id(copyData2))
print(id(copyData3))
print(id(copyData4))

当修改任意对象时，其它对象都会受影响

copyData3[1][“chars”][1] = “BBB”

查看所有对象的数据

print(originData)
print(copyData1)
print(copyData2)
print(copyData3)
print(copyData4)


### 深拷贝

import copy

原始数据

originData = [[1,2],{“name”:“Tom”, “chars”:[“A”,“B”]}]

使用 copy模块中的deepcopy方法获取深拷贝对象

deepCopyData = copy.deepcopy(originData)

拷贝成功的验证，内容相同，地址不同

查看所有对象内容

print(originData)
print(deepCopyData)

查看所有对象的址,

print(id(originData))
print(id(deepCopyData))

当修改任意对象时，其它对象都不会受影响

originData[1][“chars”][1] = “BBB”

查看所有对象的数据

print(originData)
print(deepCopyData)

### f 条件判断

Python 中使用 if 保留字来组成选择语句，其最简单的语法形式如下：

if 表达式:
语句块


其中，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式（例如， 是否是测试工程师），如果表达式的值为真，则执行“测试工程师”的打印；如果表达式的值为假，就跳过“语句块”，继续执行后面的语句。这种形式的 if 语句相当于汉语里的“如果……就……”，其流 程图如图所示。

[image]

把以上流程转换成为Python代码

student = “测试工程师”

if student == “测试工程师”:
print(“测试工程师”)
print(“学测试\n认准霍格沃兹测试开发”)


### if... else 判断语句

如果遇到只能二选一的条件，Python 中提供了 if…else 语句解决类似问题，其语法格式如下：

if 表达式:
语句块1
else:
语句块2


使用 if…else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式(例如判断 school 是否为 hogwarts)，如果满足条件，则执行 if 后面的语句块（打印霍格沃兹测试开发），否则，执行 else 后面的语句块（打印测试开发）。这种形式的选择语句相当于汉语里的“如果……否则……”，其流程图如图所示。

[image]

把以上流程转换成为Python代码

student = “测试工程师”
school = “hogwarts”

if school == “hogwarts”:
print(“霍格沃兹测试开发”)
else:
print(“测试开发”)


### if... elif... else 多重条件

平时网上购物时，通常都有多种付款方式以供选择，比如支付宝支付、银联支付、微信支付等等。这时用户就需要从多个选项中选择一个。在开发程序时，如果遇到多选一的情况，则可以使用 if…elif…else 语句，该语句是一个多分支选择语句，通常表现为“如果满足某种条件，进行某种处理，否则，如果满足另一种条件，则执行另一种处理……”。if…elif…else 语句的语法格式如下：

if 表达式:
语句块1
elif 表达式:
语句块2
…
else:
语句块n


使用 if…elif…else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式(例如判断 food 是否为 apple)，如果满足条件，则执行 if 后面的语句块（打印苹果），如果表达式为假，就跳过第一个语句块，进行第二个表达式的执行（例如判断 food 是否为 banana），如果满足条件，则执行 if 后面的语句块（打印香蕉），如果表达式为假，就跳过第二个语句块，进行第三个表达式的执行（例如判断 food 是否为 orange），如果满足条件，则执行 if 后面的语句块（打印橘子），如果表达式为假，就跳过第三个语句块，执行 else 后面的语句块。只有在所有表达式都为假的情况下，才会执行 else 中的语句。这种形式的选择语句相当于汉语里的“如果……如果……否则……”，其流程图如图所示。

[image]

把以上流程转换成为 Python 代码

food = input(“请输入水果的类型:\n”)

if food == “apple”:
print(“你输入的是苹果”)
elif food == “banana”:
print(“你输入的是香蕉”)
elif food == “orange”:
print(“你输入的是橘子”)
else:
print(“你触及了我翻译的盲区了:(”)


### 分支嵌套

前面介绍了 3 种形式的 if 选择语句，这 3 种形式的选择语句之间都可以进行互相嵌套。例如，在最简单的 if 语句中嵌套 if…else 语句，形式如下：

if 表达式 1:
if 表达式 2:
语句块 1
else:
语句块 2


也能在 else 语句中嵌套

if 表达式 1:
if 表达式 2:
语句块 1
else:
语句块 2
else:
if 表达式 3:
语句块 3
else:
语句块 4


还能在 elif 语句中嵌套

if 表达式 1:
if 表达式 2:
语句块 1
else:
语句块 2
elif 表达式 3:
if 表达式 4:
语句块 3
else:
语句块 4
else:
if 表达式 5:
语句块 5
else:
语句块 6


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

接下来使用本章节所学习的条件语句，将课程开始的例子转换成 Python 代码之后的效果：

name = input(“请输入你的名字：\n”)
hobby = int(input(“请选择你擅长/喜欢的科目，文科选1，理科选2：\n”))
if hobby == 1:
orientation_choose = int(input(“请选择你想要的职业，历史选1，地理选2：\n”))
if orientation_choose == 1:
orientation = “历史”
else:
orientation = “地理”
else:
orientation_choose = int(input(“请选择你想从业的方向：数学选1，生物选2，编程选3\n”))
if orientation_choose == 1:
orientation = “数学”
elif orientation_choose == 2:
orientation = “生物”
else:
coder_choose = int(input(“请选择你想从事的软件职业方向：测试选1，开发选2，产品选3，项目经理选4\n”))
if coder_choose == 1:
orientation = “测试”
elif coder_choose == 2:
orientation = “开发”
elif coder_choose == 3:
orientation = “产品”
else:
orientation = “项目经理”
print(f"{name} 同学，你意向的职业为: {orientation}")


通过转换出来的代码，就能使用条件语句 if 实现学生的求职意向调查的简单逻辑了。
### 作业要求

编写一个Python程序，输入一个5位数，判断输入的这个数字是否为回文数。回文数是指从左到右和从右到左读都一样的数。例如12321。如果输入的是回文数，输出是回文数，否则输出不是回文数。

### 解题思路

1. 获取用户输入： 使用 `input()` 函数接收用户输入的一个5位数。
2. 判断是否为回文数： 将输入的数转换为字符串，并逆序排列，然后与原字符串比较。如果两者相等，则为回文数，否则不是回文数。
3. 输出结果： 根据判断结果输出相应的信息。

#### 完整代码

num = input(“请输入一个5位数：”)
if num == num[::-1]:
print(f"{num} 是一个回文数!“)
else:
print(f”{num} 不是一个回文数!")


#### 代码讲解

1. `num = input("请输入一个5位数：")`：通过 `input` 函数获取用户输入的字符串，并将其赋值给变量 `num`。
2. `if num == num[::-1]`：使用切片 `[::-1]` 反转字符串，然后将反转后的字符串与原始字符串进行比较。如果它们相等，说明这个数是回文数。
### 作业要求

编写一个 Python 程序，用户输入一个分数，程序将根据分数判断并输出相应的等级。分数在 90 分及以上为 A 等级，60 -89 分为 B 等级，否则为 C 等级。

### 解题思路

1. 获取用户输入的分数。
2. 判断分数所属的等级范围，并根据判断结果输出相应的等级。

#### 完整代码

用户输入分数

score = int(input(‘输入分数:\n’))

根据分数判断等级

if score >= 90:
grade = ‘A’
elif score >= 60:
grade = ‘B’
else:
grade = ‘C’

输出等级和分数

print(f"{score} 属于 {grade} 等级")


#### 代码讲解

1. `score = int(input("请输入分数："))`：使用 `input` 函数获取用户输入的分数，并使用 int 函数将输入转换为整数类型，将其存储在变量 `score` 中。
2. `if score >= 90`：使用 `if` 条件语句判断分数是否大于等于90。
3. `elif score >= 60`：使用 `elif` 条件语句判断分数是否大于等于60，同时不满足第一个条件。
4. `else`：如果上述两个条件都不满足，即分数小于60，执行 `else` 语句块。
5. 在每个条件语句块中，将相应的等级（A、B、C）赋值给变量 `grade`。
6. `print(f"{score} 属于 {grade} 等级")`：使用 print 函数输出判断结果，显示用户输入的分数以及对应的等级。
### 作业要求

编写一个简单的Python程序，实现一个简易的计算器。用户可以输入两个数字和一个运算符（+、-、*、/），程序将根据运算符执行相应的计算操作，并输出结果。

### 解题思路

1. 提示用户输入要进行的运算操作的运算符。
2. 根据输入的运算符，使用条件语句执行相应的计算操作，并将结果存储在一个变量中。
3. 输出计算结果。

#### 完整代码

num1 = float(input(“请输入第一个数字：”))
num2 = float(input(“请输入第二个数字：”))
operator = input(“请输入运算符（+、-、*、/）：”)

根据运算符执行相应的计算操作

if operator == ‘+’:
result = num1 + num2
elif operator == ‘-’:
result = num1 - num2
elif operator == ‘*’:
result = num1 * num2
elif operator == ‘/’:
if num2 != 0:
result = num1 / num2
else:
result = “除数不能为零”
else:
result = “无效运算符”

输出计算结果

print(“计算结果：”, result)


#### 代码讲解

1. `num1 = float(input("请输入第一个数字："))`：这行代码提示用户输入第一个数字，并使用`input()`函数获取用户输入的字符串，然后使用`float()`函数将其转换为浮点数类型，以便进行数学运算。
2. `num2 = float(input("请输入第二个数字："))`：与上一行类似，这行代码提示用户输入第二个数字并转换为浮点数。
3. `operator = input("请输入运算符（+、-、*、/）：")`：这行代码提示用户输入运算符，运算符可以是加法（+）、减法（-）、乘法（*）或除法（/）。
4. 接下来是条件语句部分，根据用户输入的运算符，执行相应的计算操作。使用`if`、`elif`和`else`语句来进行条件判断。例如，如果运算符是加法（+），则执行num1 + num2。
5. `print("计算结果：", result)`：使用`print()`函数输出计算结果，同时将字符串 "计算结果：" 与结果变量 `result` 进行拼接。

### 作业要求

编写一个 Python 程序，模拟乘坐公交车过程，并且可以有座位坐下。要求：输入公交卡当前的余额，只要不低于2元，就可以上公交车；如果车上有空座位，就可以坐下。

#### 解题思路

1. 获取输入的公交卡余额。
2. 判断输入的余额是否大于等于2。
3. 如果余额大于等于2，继续获取车上是否有空座位，再继续进行判断。

#### 完整代码

CardCash = int(input(‘请输入您的公交卡余额：’))
if CardCash >= 2:
print(‘余额足够，您可以上车了’)
isSeat = input(‘车上是否有空座位(有/没有)？’)
if isSeat == ‘有’:
print(‘您可以坐下’)
else:
print(‘没有座位，只能站着’)
else:
print(‘余额不够，您不能上车’)


#### 代码讲解

1. `CardCash = int(input('请输入您的公交卡余额：'))`：使用input() 函数获取用户输入的余额，并转换成 `int` 类型，再赋值给变量`CardCash`。
2. `if CardCash >= 2`：用于判断余额是否大于等于2。如果条件为真，即余额足够支付车费，继续执行下面的代码。反之，则打印余额不够，您不能上车
3. `isSeat = input('车上是否有空座位(有/没有)？')`：这行代码用于获取用户输入，询问车上是否有空座位，将用户的输入数据赋值给变量 `isSeat`。
4. `if isSeat == '有'`：用于判断是否有空座位，如果条件为真，打印您可以坐下。反之，则打印没有座位，只能站着。
### 作业要求

编写一个 Python 程序，模拟乘坐公交车过程，并且可以有座位坐下。要求：输入公交卡当前的余额，只要不低于2元，就可以上公交车；如果车上有空座位，就可以坐下。

#### 解题思路

1. 获取输入的公交卡余额。
2. 判断输入的余额是否大于等于2。
3. 如果余额大于等于2，继续获取车上是否有空座位，再继续进行判断。

#### 完整代码

CardCash = int(input(‘请输入您的公交卡余额：’))
if CardCash >= 2:
print(‘余额足够，您可以上车了’)
isSeat = input(‘车上是否有空座位(有/没有)？’)
if isSeat == ‘有’:
print(‘您可以坐下’)
else:
print(‘没有座位，只能站着’)
else:
print(‘余额不够，您不能上车’)


#### 代码讲解

1. `CardCash = int(input('请输入您的公交卡余额：'))`：使用input() 函数获取用户输入的余额，并转换成 `int` 类型，再赋值给变量`CardCash`。
2. `if CardCash >= 2`：用于判断余额是否大于等于2。如果条件为真，即余额足够支付车费，继续执行下面的代码。反之，则打印余额不够，您不能上车
3. `isSeat = input('车上是否有空座位(有/没有)？')`：这行代码用于获取用户输入，询问车上是否有空座位，将用户的输入数据赋值给变量 `isSeat`。
4. `if isSeat == '有'`：用于判断是否有空座位，如果条件为真，打印您可以坐下。反之，则打印没有座位，只能站着。

## 循环语句-while
循环主要有两种类型：

* 重复一定次数的循环，称为计次循环，如 for 循环。
* 一直重复，直到条件不满足时才结束的循环，称为条件循环。只要条件为真，这种循环会一直持续下去，如 while 循环。

后面的章节将对这两种类型的循环分别进行介绍。

### 程序中的循环

* 循环语句允许执行一个语句或语句块多次，当有重复运行一个代码块的需求时，不需要也不能多次复制来实现（有时候事先都无法知道什么时候需要循环结束，所以复制多次来实现基本是不可能的），
* Python 提供了 for 循环和 while 循环两种类型的循环可以应对不同的使用场景。
* 下图是大多数编程语言中循环语句的一般形式

[image]

在程序开始之后，会进入一个判断（或者是先执行一个语句后再进入判断），判断条件成立的时候就会再次执行语句块，执行完成该语句块之后会再进行判断条件是否符合，不符合时就会结束循环，否则一直循环执行下去。

说明：在其他语言中（例如，C、C++、Java 等），条件循环还包括 do…while 循环，但 是，在 Python 中没有 do…while 循环。

### 循环的作用

* 提高代码复用性，减少代码冗余
* 遍历序列（字符串，元组，列表，字典等）

### 循环的构成要素

* 初始化语句： 一条或多条语句，用于完成一些初始化工作。初始在循环开始之前执行。
* 循环条件：一般是一个布尔表达式，这个表达式能决定是否执行循环体
* 循环体：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。
* 迭代语句：这个部分在每次执行循环体结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量向趋近于结束条件改变。

上面四个部分只是一般分类，并不是每个循环中都非常清晰地分出这几个部分。

### 什么是 while 循环

在日常的生活中有时候循环的次数通常不会在刚开始就知道，而是满足条件之后就停止循环，如有一路公交车不是固定时间间隔发车，而是在人数满足多少个之后就发车，一直到晚上的11点准时收工，那么没有到11点的话就会一直重复，直到条件不满足时才结束的循环，称为条件循环。只要条件为真，这种循环会一直持续下去，通常指的是 while 循环。

### while 循环的语法

while 条件表达式:
循环体


当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达 式的返回值，直到表达式返回的结果为假时，退出循环。

以生活中的例子来理解 while 循环的执行流程，在年会上，主持人要求参与人沿着主持台跑圈。要求当听到主持人喊停止时就停下来。参与者每跑一圈，可能会请求一次主持人发起停止指令。如果老师喊停，则停下来，即循环结束。否则继续跑步，即执行循环。

### while 循环实战

**实战1：** 求 1~10 之间所有整数的乘积。

保存结果的变量

result = 1

循环控制变量

n = 2

开始循环

while n <= 10:
# 计算乘积
result *= n
# 改变循环变量向结束条件趋近
n += 1

输出结果

print(“1~10的乘积为：”, result)


**实战2：** 输入密码，直到密码输入正确，输出”登录成功“。

password = “password” # 设置正确的密码
input_password = “”

while input_password != password:
input_password = input("请输入密码: ")

print(“密码正确，登录成功！”)


**实战3：** 在行酒令中，有一个数7小游戏，游戏参与者依次报数，但需要跳过所有包含7或7的整数倍的数字，编写程序找出1~100范围内所有符合该条件的数字。

循环变量实始化

n = 1

循环条件

while n<=100:
# 数字对7求模为0，则表示该数字是7的倍数
# 将数字转换为字符串类型，使用成员运算符判断字符7是否在字符串中，检查包含关系
if n % 7 == 0 or “7” in str(n):
# 输出满足条件的数字
print(n)
# 改变循环变量趋近于结束条件
n += 1


## 循环语句-for-in

Python并没有提供类似C语言中那种传统意义上的for循环，而是提供了一种专门处理字符串，元组，列表，字典等可迭代的序列类型数据的增强型for循环。

### for-in 循环的语法

for 迭代变量 in 对象:
循环体


for-in 循环会将可迭代对象中的元素依次取出，保存到迭代变量中。每取出一个变量，便执行一次循环体，在循环体中可以通过引用迭代变量，使用取出的数据。

### 遍历可迭代对象

使用for-in循环处理可迭代对象，可以使操作过程变的极其简单。

#### 遍历字符串

s = “Hello Hogworts!”
for c in s:
print(c)


示例： 输出前面示例中每个字符对应的ASCII码值。

s = “Hello Hogworts!”
for c in s:
print(f"字符【 {c} 】的ASCII码为：【 {ord(c)} 】")


#### 遍历元组

t = (1,2,3,4,5)
for n in t:
print(n)


示例：输出前面示例元组中每个数字的立方值

t = (1,2,3,4,5)
for n in t:
print(f"数字【 {n} 】的立方值为：【 {n*3} 】")


#### 遍历列表

requestMethods = [“get”, “post”, “put”,“delete”, “patch”, “header”, “options”,‘trace’]
for method in requestMethods:
print(method)


示例：将前面示例列表中所有的请求方式转换为大写输出

requestMethods = [“get”, “post”, “put”,“delete”, “patch”, “header”, “options”,‘trace’]
for method in requestMethods:
print(f"请求方式【 {method} 】转换为大写后：【 {method.upper()} 】")


#### 遍历字典

requestMethods = {
“get”: “用于获取服务器上的资源，通过在URL中传递参数来发送请求。”,
“post”: “用于向服务器提交数据，一般用于创建新的资源或进行修改操作。”,
“put”: “用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。”,
“delete”: “用于删除服务器上的资源。”
}
for method in requestMethods:
print(method)


从前面的代码中可以看出，字典是一个比较特殊的数据类型，由key-value组成，在使用for-in遍历字典时，默认遍历的是字典的所有key,相当于下面的代码

requestMethods = {
“get”: “用于获取服务器上的资源，通过在URL中传递参数来发送请求。”,
“post”: “用于向服务器提交数据，一般用于创建新的资源或进行修改操作。”,
“put”: “用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。”,
“delete”: “用于删除服务器上的资源。”
}
for method in requestMethods.keys():
print(method)


如果想遍历字典中的所有值，可以使用下面的方式

requestMethods = {
“get”: “用于获取服务器上的资源，通过在URL中传递参数来发送请求。”,
“post”: “用于向服务器提交数据，一般用于创建新的资源或进行修改操作。”,
“put”: “用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。”,
“delete”: “用于删除服务器上的资源。”
}
for method in requestMethods.values():
print(method)


但是直接对字典取值遍历的使用方式大多数情况下是无意义的。

示例： 通过遍历字典的key,输出每个key对应的值。

requestMethods = {
“get”: “用于获取服务器上的资源，通过在URL中传递参数来发送请求。”,
“post”: “用于向服务器提交数据，一般用于创建新的资源或进行修改操作。”,
“put”: “用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。”,
“delete”: “用于删除服务器上的资源。”
}
for method in requestMethods:
print(f"请求方式【 {method} 】的作用为：【 {requestMethods[method]} 】")


此种方式虽然可以取到结果，但是for-in循环在遍历字符时，配合字典的`items()`方法，实现更简单的方法

requestMethods = {
“get”: “用于获取服务器上的资源，通过在URL中传递参数来发送请求。”,
“post”: “用于向服务器提交数据，一般用于创建新的资源或进行修改操作。”,
“put”: “用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。”,
“delete”: “用于删除服务器上的资源。”
}
for item in requestMethods.items():
print(f"请求方式【 {item[0]} 】的作用为：【 {item[1]} 】")


甚至，代码还可以配合解包操作，更简单的实现

requestMethods = {
“get”: “用于获取服务器上的资源，通过在URL中传递参数来发送请求。”,
“post”: “用于向服务器提交数据，一般用于创建新的资源或进行修改操作。”,
“put”: “用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。”,
“delete”: “用于删除服务器上的资源。”
}
for key, value in requestMethods.items():
print(f"请求方式【 {key} 】的作用为：【 {value} 】")

## 数字序列

在使用for-in循环时，默认是无法实现类似传统for循环方式的使用形式，但是可以配合 `range()` 函数实现传统的计次循环。 当然，也可以通过while循环来实现计次循环。 在实现某个功能时，循环可以相互替代实现。

### range函数

range() 函数是一个用于生成整数序列的内置函数，通过指定起始值、停止值和步长，它能够生成一个按照指定规则递增或递减的整数序列。

range() 通常用于配合for-in循环结构中控制迭代次数或遍历特定范围的情况使用。

### range函数的基本语法

格式：`range(start, stop, step)`

* `start` : 可选参数，表示起始值，默认为0。
* `stop` : 表示结束值，不包含在范围内。
* `step` : 可选参数， 表示步长，默认为1。

确定开始和结束范围

nums = list(range(1, 10))
print(nums)

使用默认开始值

nums = list(range(10))
print(nums)

确定范围和步长

nums = list(range(1, 10, 2))
print(nums)

使用负步长

nums = list(range(10, 1, -3))
print(nums)


#### for-in结合range函数实现计次循环

for i in range(10):
print(i)


示例：计算 1~100 的整数和

result = 0
for i in range(1, 101):
result += i

print(result)


### 随机数

在程序开发过程中，经常会使用到随机数，Python 中 ，可以使用 `random` 模块中的 `randint()` 函数获取随机数。

格式： `randint(start, stop)`

* `start` 为随机数获取初始范围
* `stop` 为随机数获取结束范围，包含该值。
* 使用该函数前需要导入， `from random import randint`

from random import randint
print(randint(1, 3))


示例： 骰子游戏： 从键盘输入一个数字，和程序随机生成的 1~6范围的数字比较大小

from random import randint

play = int(input(“请输入一个1-6之间的数字：”))
bot = randint(1, 6)

if play == bot:
print(“点数相同，平局”)
elif play > bot:
print(f"玩家{play}点，电脑{bot}点，玩家胜")
else:
print(f"玩家{play}点，电脑{bot}点，电脑胜")