目录
背景：Python 是一种广泛使用的高级编程语言，以其简洁、易读和强大的功能而著称。它支持多种编程范式，包括面向对象、命令式和函数式编程。下面我将详细介绍 Python 的一些基本语法元素
1、注释
Python 中使用井号（#）来标记注释。注释可以单独占一行，也可以跟在代码后面。注释用户对代码的功能和作用进行解释，但不会被 Python 解释器执行。为了代码的可读性，建议在#后面空一个空格再写注释。
多行注释用ctrl+/,取消多行注释也是ctrl+/
#单独占一行
print('hello world')#跟在代码后面
#多行注释用ctrl+/
# print('hello world')
# print('hello world')
# print('hello world')2、打印函数print（）
Python 中的 print() 函数是一个内置函数，用于向标准输出设备（通常是控制台）输出信息。这个函数非常灵活，可以接受多个参数，并且可以通过一些关键字参数来控制输出的格式。
2.1基本用法
最简单的 print() 调用是输出一个字符串或变量的值。
print("Hello, World!")
x = 10
print(x)2.2输出多个参数
print() 可以一次输出多个项，它们之间默认用空格分隔。
print("Hello", "World", "Python")
# 输出: Hello World Python2.3sep设置分隔符
可以通过 sep 关键字参数来自定义项之间的分隔符。
print("Hello", "World", "Python", sep="-")
# 输出: Hello-World-Python2.4end设置结束符
默认情况下，print() 函数在输出内容后会添加一个换行符（\n）。你可以通过 end 关键字参数来修改这个行为。
print("Hello, ", end="")
print("World!")
# 输出: Hello, World!2.5文件输出
print() 还可以将输出重定向到文件。这通过 file 关键字参数实现。
with open("output.txt", "w") as f:
print("Hello, World!", file=f)
# 此时，"Hello, World!" 被写入到 output.txt 文件中2.6格式化输出
print() 支持字符串格式化，可以使用老式的 % 格式化或者新的 .format() 方法。格式为print（"格式化字符串"%(变量1，变量.....)）
%s代表字符串，%d有符号十进制整数，%f浮点数
name = "Alice"
print("Hello, %s!" % name)
# 输出: Hello, Alice!name = "Bob"
print("Hello, {}!".format(name))
# 输出: Hello, Bob!3、输入函数input（）
input()函数是一个非常基础且强大的函数，它允许程序暂停执行并等待用户从标准输入（通常是键盘）输入一些数据。一旦用户按下回车键，输入的数据就会被读取，并可以作为一个字符串（str）返回给程序。
# 使用input函数接收用户输入
name = input("请输入你的名字: ")
# 打印用户输入的内容
print("你的名字为:", name)无论用户输入的是什么（数字、单词、句子等），input()函数总是将输入作为字符串返回。如果你需要其他类型的数据（如整数或浮点数），你需要使用相应的类型转换函数（如int()、float()）将字符串转换为所需的类型。
age_str = input("请输入你的年龄: ")
age = int(age_str) # 将字符串转换为整数
print("你的年龄是:", age)4、变量
Python中的变量是一种用于存储数据的容器，它允许我们在程序中引用和修改这些数据。Python是一种动态类型语言，Python 中的变量不需要事先声明类型。这意味着变量的类型不是在声明时固定的，而是在赋值时由存储在该变量中的数据决定。变量名可以是字母、数字或下划线的任意组合，但不能以数字开头。Python 是大小写敏感的。
4.1变量赋值
在Python中，变量是通过赋值语句来创建的。赋值语句的语法非常简单：变量名后跟等号（=），等号后面是变量要存储的值或表达式的结果。
x = 5 # 创建一个名为x的变量，并赋值为5
y = "Hello, World!" # 创建一个名为y的变量，并赋值为字符串"Hello, World!"4.2变量类型
由于Python是动态类型语言，因此变量类型不是固定的。但是，你可以通过内置函数type()来检查变量的类型
x = 5
print(type(x)) # 输出：<class 'int'>
y = "Hello"
print(type(y)) # 输出：<class 'str'>4.3基本数据类型
-
整数（int）：用于表示整数值，如
1、-10、100等。Python的整数类型没有大小限制，可以表示任意大小的整数。 -
浮点数（float）：用于表示带有小数点的数字，如
3.14、-0.001等。浮点数运算可能会存在四舍五入的误差。 -
布尔值（bool）：只有两个值，
True和False，用于表示逻辑值。 -
字符串（str）：用于存储文本数据，由单引号（'）、双引号（"）或三引号（'''或"""）包围的任意文本。字符串是不可变的，但可以通过拼接等方式生成新的字符串。
-
列表（list）：用于存储一系列有序的元素，这些元素可以是不同类型的数据。列表是可变的，可以添加、删除或修改列表中的元素。
-
元组（tuple）：与列表类似，但元组是不可变的。一旦创建了元组，就不能修改它的元素。元组使用圆括号（()）表示。
-
集合（set）：一个无序的、不包含重复元素的集合。主要用于数学上的集合操作，如并集、交集、差集和对称差集等。
-
字典（dict）：用于存储键值对，每个键都映射到一个值。字典中的键必须是唯一的，而值则不必。字典是无序的，但可以保持插入顺序（Python 3.7+）。字典是可变的，可以添加、删除或修改键值对。
-
字节（bytes）和字节数组（bytearray）：用于处理二进制数据，bytes是不可变的，而bytearray是可变的
# 整数 x = 10 print(type(x)) # 输出：<class 'int'> # 浮点数 y = 3.14 print(type(y)) # 输出：<class 'float'> # 布尔值 is_valid = True print(type(is_valid)) # 输出：<class 'bool'> # 字符串 name = "Alice" print(type(name)) # 输出：<class 'str'> # 列表 numbers = [1, 2, 3, 4, 5] print(type(numbers)) # 输出：<class 'list'> # 元组 point = (10, 20) print(type(point)) # 输出：<class 'tuple'> # 集合 fruits = {'apple', 'banana', 'orange'} print(type(fruits)) # 输出：<class 'set'> # 字典 person = {'name': 'Alice', 'age': 30} print(type(person)) # 输出：<class 'dict'> # 类型转换 x_str = str(x) print(x_str) # 输出：'10' x_float = float(x) print(x_float) # 输出：10.05、运算符
Python中的运算符是编写Python程序时不可或缺的元素，它们用于执行各种操作，如算术运算、比较运算、逻辑运算和位运算等。
Python中的运算符是编写Python程序时不可或缺的元素，它们用于执行各种操作，如算术运算、比较运算、逻辑运算和位运算等。以下是Python中运算符的使用教程：
5.1算术运算符
算术运算符用于执行基本的数学运算。
- 加法 (
+)：用于将两个操作数相加。 - 减法 (
-)：用于将第一个操作数减去第二个操作数。 - 乘法 (
*)：用于将两个操作数相乘。 - 除法 (
/)：用于将第一个操作数除以第二个操作数，结果为浮点数。 - 整除 (
//)：用于执行两个数的整除操作，结果为整数，向下取整。 - 取余 (
%)：用于计算两个数相除后的余数。 - 幂 (
**)：用于执行一个数的指数运算。# 加法 a = 5 + 3 print(a) # 输出: 8 # 减法 b = 10 - 4 print(b) # 输出: 6 # 乘法 c = 2 * 3 print(c) # 输出: 6 # 除法 d = 10 / 2 print(d) # 输出: 5.0 # 整除 e = 10 // 3 print(e) # 输出: 3 # 取余 f = 10 % 3 print(f) # 输出: 1 # 幂 g = 2 ** 3 print(g) # 输出: 8
5.2比较运算符
比较运算符用于比较两个值，并返回一个布尔值（True或False）。
- 等于 (
==)：检查两个值是否相等。 - 不等于 (
!=)：检查两个值是否不相等。 - 大于 (
>)：检查左侧的值是否大于右侧的值。 - 小于 (
<)：检查左侧的值是否小于右侧的值。 - 大于等于 (
>=)：检查左侧的值是否大于等于右侧的值。 - 小于等于 (
<=)：检查左侧的值是否小于或等于右侧的值。# 等于 x = 5 y = 5 print(x == y) # 输出: True # 不等于 print(x != 6) # 输出: True # 大于 print(x > 3) # 输出: True # 小于 print(x < 6) # 输出: True # 大于等于 print(x >= 5) # 输出: True # 小于等于 print(x <= 5) # 输出: True
5.3赋值运算符
赋值运算符用于给变量赋值。
- 简单赋值 (
=)：将右侧的值赋给左侧的变量。 - 增量赋值 (如
+=,-=,*=,/=,%=,//=,**=)：这些运算符结合了运算和赋值，将运算结果赋给左侧的变量。# 简单赋值 h = 10 print(h) # 输出: 10 # 增量赋值 h += 5 # 等同于 h = h + 5 print(h) # 输出: 15 h *= 2 # 等同于 h = h * 2 print(h) # 输出: 30 # 其他增量赋值运算符类似
5.4逻辑运算符
逻辑运算符用于执行逻辑运算。
- 与 (
and)：如果两个条件都为真，则返回True，否则返回False。 - 或 (
or)：如果两个条件中至少有一个为真，则返回True，否则返回False。 - 非 (
not)：将条件的结果取反，如果条件为真，则返回False，如果条件为假，则返回True。# 与 print(True and True) # 输出: True print(True and False) # 输出: False # 或 print(True or False) # 输出: True print(False or False) # 输出: False # 非 print(not True) # 输出: False print(not False) # 输出: True
5.5身份运算符
身份运算符用于比较两个对象的身份。
is：如果两个变量是同一个对象，则返回True。is not：如果两个变量不是同一个对象，则返回True。# is a = [1, 2, 3] b = a c = [1, 2, 3] print(a is b) # 输出: True，因为a和b指向同一个对象 print(a is c) # 输出: False，尽管内容相同，但a和c不是同一个对象 # is not print(a is not c) # 输出: True
5.6成员运算符
成员运算符用于测试一个值是否是一个序列（如列表、元组或字符串）的成员。
in：如果在序列中找到该值，则返回True。not in：如果在序列中没有找到该值，则返回True。# in my_list = [1, 2, 3, 4, 5] print(3 in my_list) # 输出: True # not in print(6 not in my_list) # 输出: True
5.7位运算符
位运算符用于对整数进行位级操作。
- 按位与 (
&)：对两个数的二进制表示进行按位与操作。 - 按位或 (
|)：对两个数的二进制表示进行按位或操作。 - 按位异或 (
^)：对两个数的二进制表示进行按位异或操作。 - 按位取反 (
~)：对一个数的二进制表示进行按位取反操作。 - 左移 (
<<)：将一个数的二进制表示向左移动指定的位数。 - 右移 (
>>)：将一个数的二进制表示向右移动指定的位数。# 按位与 a = 60 # 二进制 0011 1100 b = 13 # 二进制 0000 1101 print(a & b) # 输出: 12 (二进制 0000 1100) # 按位或 print(a | b) # 输出: 61 (二进制 0011 1101) # 按位异或 print(a ^ b) # 输出: 49 (二进制 0011 0001) # 按位取反 print(~a) # 输出: -61，因为Python中整数是补码形式，取反后加1等于原数的相反数 # 左移 print(a << 2) # 输出: 240 (二进制 1111 0000) # 右移 print(a >> 2) # 输出: 15 (二进制 0000 1111)
5.8运算符优先级
Python中的运算符有不同的优先级，这决定了在一个表达式中各个运算符的执行顺序。通常，括号 () 的优先级最高，用于改变默认的运算顺序。其他运算符的优先级从高到低依次为：幂运算符 **、正负号 +x, -x、乘法 *、除法 /、取模 %、取整除法 //、加法 +、减法 -、位运算符（<<, >>, &, ^, |）、比较运算符（<, <=, >, >=, ==, !=）、逻辑运算符（not, and, or）和赋值运算符（= 及其复合形式）。
6、条件判断
6.1if elif语句
Python中的条件判断是通过if、elif（else if 的缩写）、和else语句来实现的。这些语句允许程序根据条件（布尔表达式）的真假来执行不同的代码块。条件判断是编程中非常基础且强大的概念，它使得程序能够根据不同的输入或状态来做出不同的响应。
if 条件表达式:
# 如果条件为真，则执行这里的代码块
pass
elif 条件表达式2:
# 如果条件表达式为假，但条件表达式2为真，则执行这里的代码块
pass
else:
# 如果前面的条件表达式都为假，则执行这里的代码块
passif后面跟着一个条件表达式，如果条件为真（True），则执行if语句块中的代码。elif（可选）是else if的缩写，用于提供额外的条件测试。如果前面的if或elif条件都不满足，Python会检查下一个elif语句的条件。else（可选）部分在所有的if和elif条件都不满足时执行。pass是一个空操作语句，用作占位符，当语法上需要语句但程序不需要执行任何操作时可以使用。# 假设我们要根据年龄来打印不同的消息 age = 20 if age < 13: print("你是一个孩子。") elif age >= 13 and age < 20: print("你是一个青少年。") elif age >= 20 and age < 65: print("你是一个成年人。") else: print("你是一位老年人。")条件表达式的结果必须是布尔值（
True或False）。但是，Python会隐式地将非布尔值（如整数、浮点数、字符串等）转换为布尔值。例如，在布尔上下文中，0、None、空字符串""、空列表[]、空元组()、空字典{}和空集合set()等都被视为False，其他所有值都被视为True
6.2match语句使用
match 语句是Python 3.10版本引入的一个新特性，它提供了一种更直观和强大的方式来进行模式匹配。虽然match语句通常与数据结构和类型相关联，但它也可以用于更广泛的条件判断场景，尤其是当需要基于不同条件执行不同代码块时。然而，需要注意的是，match语句主要用于与case标签一起，对表达式的值进行模式匹配
match subject:
case pattern1:
# 如果subject与pattern1匹配，执行这里的代码
...
case pattern2:
# 如果subject与pattern2匹配，执行这里的代码
...
case _: # 通配符模式，匹配任何值
# 如果没有其他模式匹配，执行这里的代码
...subject：是要与各个模式进行比较的表达式。pattern：是一个或多个用于与subject进行比较的模式。模式可以是字面量、变量、类型、元组、列表、字典、类实例等，也可以是使用|（或）操作符组合的模式。_：是一个特殊的通配符模式，它匹配任何值。在match语句中，它通常用作最后一个case，以捕获所有未被前面模式匹配的情况。color = "green" match color: case "red": print("Stop!") case "green" | "yellow": print("Go!") case _: print("I don't know about that color.") #在这个例子中，match语句根据color变量的值来匹配不同的模式。 #如果color是"red"，则打印"Stop!"； #如果color是"green"或"yellow"，则打印"Go!"； #如果color是其他任何值，则打印"I don't know about that color."。7、循环
Python中的循环是一种控制流语句，它允许重复执行一段代码块直到满足特定条件为止。Python提供了两种基本的循环结构：for循环和while循环。每种循环都有其特定的用途和语法。
7.1for循环
for循环用于遍历任何序列（如列表、元组或字符串）或其他可迭代对象
for 变量 in 可迭代对象:
# 循环体
passfruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)7.2while循环
while循环会在给定条件为真时重复执行一段代码块，只要条件表达式的结果为真（True），循环就会继续执行。如果条件表达式的结果为假（False），循环就会结束。
while 条件表达式:
# 循环体
passcount = 1
while count <= 5:
print(count)
count += 1
#使用while循环打印1-57.3循环控制语句
break语句：用于立即退出循环，无论是for循环还是while循环
for i in range(1, 10):
if i == 5:
break
print(i)continue语句：用于跳过当前循环的剩余语句，并继续下一次循环。
for i in range(1, 10):
if i % 2 == 0:
continue
print(i)else语句与循环：for和while循环都可以有一个可选的else子句，它在循环正常结束后执行（即不是通过break语句退出的）。
for i in range(1, 5):
print(i)
else:
print("Loop completed normally.")嵌套循环：循环可以嵌套在另一个循环内部。这意味着你可以在一个循环体内开始另一个循环。
for i in range(1, 4):
for j in range(1, i + 1):
print(f"{j}x{i}={i*j}", end='\t')
print() # 换行
#使用嵌套循环打印乘法口诀表8、组合数据类型
Python中的组合数据类型（Composite Data Types）允许你将多个值组合成一个单一的数据项。这些类型对于组织和处理复杂数据非常有用。Python中有几种主要的组合数据类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set
8.1列表
列表是Python中最常用的数据类型之一，它是一个有序的集合，可以包含不同类型的元素。列表是可变的，意味着你可以添加、删除或更改列表中的元素
创建列表： 使用方括号[]，元素之间用逗号,分隔。
my_list = [1, 2, 3, 'a', 'b', 'c']访问元素： 通过索引访问，索引从0开始。
print(my_list[0]) # 输出: 1添加元素： 使用append()在末尾添加，insert(index, value)在指定位置插入。
my_list.append(4)
my_list.insert(1, 'x')删除元素： 使用remove(value)删除第一个匹配的元素，pop(index)删除并返回指定索引的元素，默认删除最后一个元素。
my_list.remove('a')
print(my_list.pop()) # 删除并返回最后一个元素切片： 使用[start:stop:step]选择列表的一部分。
print(my_list[1:4]) # 输出: ['x', 2, 3]遍历：列表的遍历通常使用for循环。你可以直接遍历列表中的每个元素，或者通过索引和range()函数遍历（尽管后者在简单遍历中不太常见）。
my_list = [1, 2, 3, 4, 5]
for item in my_list:
print(item)
# 输出:
# 1
# 2
# 3
# 4
# 58.2元组
元组与列表类似，但它是不可变的。一旦创建了元组，就不能更改其元素（但元素本身如果是可变类型，如列表，则内部元素可以更改
创建元组： 使用圆括号()，元素之间用逗号,分隔。
my_tuple = (1, 2, 3, 'a', 'b')访问元素： 与列表相同，通过索引访问
print(my_tuple[0]) # 输出: 1切片： 也支持切片操作。
print(my_tuple[1:3]) # 输出: (2, 3)删除：del 元组
del my_tuple遍历：元组的遍历与列表的遍历非常相似，因为元组也是可迭代对象。你可以使用相同的for循环结构来遍历元组中的每个元素。
my_tuple = (1, 2, 3, 4, 5)
for item in my_tuple:
print(item)
# 输出:
# 1
# 2
# 3
# 4
# 58.3字典
字典是Python中的另一种组合数据类型，用于存储键值对（key-value pairs）。字典是无序的，但可以通过键快速访问其值
创建字典： 使用大括号{}，键值对之间用逗号,分隔，键与值之间用冒号:分隔。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}访问元素： 通过键访问值。
print(my_dict['name']) # 输出: John添加或更新元素： 直接赋值给新键或现有键。
my_dict['job'] = 'Engineer'
my_dict['age'] = 31删除元素： 使用del语句或pop()方法（后者会返回被删除的值）。
del my_dict['city']
print(my_dict.pop('age')) # 输出: 31遍历： 可以遍历字典的键、值或键值对。
for key in my_dict:
print(key)
for value in my_dict.values():
print(value)
for key, value in my_dict.items():
print(key, value)8.4集合
Python中的集合（Set）是一个无序的、不包含重复元素的数据结构。它主要用于数学上的集合操作，如并集、交集、差集和对称差集等。集合中的元素必须是不可变类型（如整数、浮点数、字符串和元组），但不能是列表或字典等可变类型
创建集合：集合可以使用大括号{}来创建，但与字典不同，集合中的元素之间用逗号,分隔，且没有键（key）和值（value）的概念。但是，注意空集合不能使用{}来创建，因为这会与空字典混淆；应该使用set()来创建空集合。
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# 创建一个空集合
empty_set = set()添加元素：使用.add()方法向集合中添加元素。
my_set = {1, 2, 3}
my_set.add(4) # 添加元素4
print(my_set) # 输出: {1, 2, 3, 4}删除元素：可以使用.remove()（如果元素存在则删除，不存在则抛出KeyError）或.discard()（如果元素存在则删除，不存在则不抛出错误）方法删除元素。还可以使用.pop()方法随机删除并返回一个元素（如果集合为空，则抛出KeyError）
my_set.remove(2) # 删除元素2
print(my_set) # 输出: {1, 3, 4}
# 如果尝试删除不存在的元素
# my_set.remove(5) # 这会抛出KeyError
my_set.discard(5) # 如果元素不存在，则不抛出错误
print(my_set) # 输出: {1, 3, 4}
# 随机删除并返回一个元素
popped_element = my_set.pop()
print(f"Popped element: {popped_element}, Set now: {my_set}")检查元素：使用in或not in关键字检查集合中是否包含某个元素。
print(3 in my_set) # 输出: True
print(5 in my_set) # 输出: False集合的并集：使用|或.union()方法合并两个集合，去除重复元素。
集合的交集：使用&或.intersection()方法找出两个集合中共有的元素。
集合的差集：使用-或.difference()方法找出存在于第一个集合中但不在第二个集合中的元素。
集合的对称差集：使用^或.symmetric_difference()方法找出存在于两个集合中但不同时存在于两个集合中的元素。
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}
# 并集
union_set = set_a | set_b # 或使用 set_a.union(set_b)
print(union_set) # 输出: {1, 2, 3, 4, 5, 6}
# 交集
intersection_set = set_a & set_b # 或使用 set_a.intersection(set_b)
print(intersection_set) # 输出: {3, 4}
# 差集
difference_set = set_a - set_b # 或使用 set_a.difference(set_b)
print(difference_set) # 输出: {1, 2}
# 对称差集
symmetric_difference_set = set_a ^ set_b # 或使用 set_a.symmetric_difference(set_b)
print(symmetric_difference_set) # 输出: {1, 2, 5, 6}9、异常
Python中的异常处理是一种非常重要的编程技术，它允许程序在运行时遇到错误时优雅地处理这些错误，而不是简单地崩溃并终止执行。异常处理通过使用try和except语句块来实现，还可以配合else和finally语句块来增强异常处理的灵活性
9.1常见的异常类型
-
Exception：所有异常的基类，所有的内置和用户定义的异常都是它的子类。通常不推荐直接捕获Exception，因为它会捕获到几乎所有的异常，包括那些你不希望捕获的（比如SystemExit、KeyboardInterrupt等），这可能会隐藏程序的真正问题。 -
AttributeError：尝试访问一个对象不存在的属性时引发的异常。 -
IOError（在Python 3.x中已被OSError取代，但IOError仍作为别名存在）：进行输入/输出操作时发生错误，如打开不存在的文件。 -
OSError：表示I/O操作失败或无法执行系统操作（如文件操作或文件系统错误）时引发的异常。它是许多I/O相关异常的基类。 -
ImportError：无法导入模块或包时引发的异常。 -
IndentationError：缩进错误，这是语法错误的一种，但Python会将其视为异常。 -
IndexError：使用序列中不存在的索引时引发的异常，比如访问列表的索引超出了其长度范围。 -
KeyError：尝试访问字典中不存在的键时引发的异常。 -
KeyboardInterrupt：用户中断执行（通常是按下Ctrl+C）时引发的异常。 -
NameError：尝试访问一个未被定义的局部变量或函数时引发的异常。 -
SyntaxError：语法错误，比如拼写错误、缺少冒号等。这通常是解析代码时发现的错误，不是通过异常处理机制来捕获的，但Python会将其视为一个异常。 -
TypeError：对类型进行了不支持的操作时引发的异常，比如尝试将非数字字符串与数字相加。 -
ValueError：当传入的参数类型正确，但值不适合函数或操作的要求时引发的异常。比如，将int()函数应用于非数字的字符串。 -
ZeroDivisionError：尝试除以零时引发的异常。 -
AssertionError：assert语句失败时引发的异常，用于调试目的。 -
FileNotFoundError（Python 3.x中新增）：当尝试打开的文件不存在时引发的异常，是OSError的一个子类。 -
PermissionError（Python 3.3+）：当操作系统不允许程序执行某个操作时引发的异常，比如没有文件的写权限。
9.2异常处理的基本机构
- try块：包含可能引发异常的代码。
- except块：用于捕获并处理try块中发生的异常。可以指定捕获特定类型的异常，也可以不指定以捕获所有类型的异常。
- else块（可选）：如果try块中的代码没有引发异常，则执行else块中的代码。
- finally块（可选）：无论是否发生异常，finally块中的代码都会被执行。通常用于执行清理操作，如关闭文件或释放资源。
假设我们要编写一个程序，该程序尝试将用户输入的字符串转换为整数。如果输入的是有效的整数字符串，则打印转换后的整数；如果输入的不是有效的整数字符串，则捕获ValueError异常并打印一条错误消息。
try:
# 尝试将用户输入转换为整数
user_input = input("请输入一个整数：")
number = int(user_input)
print(f"您输入的整数是：{number}")
except ValueError:
# 如果转换失败，捕获ValueError异常
print("输入错误，请输入一个有效的整数。")
else:
# 如果try块中没有引发异常，则执行（在这个例子中，这个else块其实有点多余，因为print语句已经在try块中了）
# 但为了演示else的用法，我们暂时保留它
print("输入成功，没有发生异常。")
finally:
# 无论是否发生异常，都会执行finally块中的代码
print("程序执行完毕，进行清理工作（如果有的话）。")在这个例子中，如果用户输入的是"123"，则程序会打印"您输入的整数是：123"和"输入成功，没有发生异常。"以及"程序执行完毕，进行清理工作（如果有的话）。"。如果用户输入的是"abc"，则程序会捕获ValueError异常，打印"输入错误，请输入一个有效的整数。"，然后仍然会打印"程序执行完毕，进行清理工作（如果有的话）。"。
9.3捕获多个异常
可以使用同一个except语句来捕获多个异常，只需将异常类型放在括号中并用逗号分隔即可。
try:
# 尝试执行可能引发多种异常的代码
pass
except (TypeError, ValueError) as e:
# 捕获TypeError或ValueError异常
print(f"发生错误：{e}")9.4捕获所有的异常
可以使用Exception来捕获所有类型的异常（但请注意，这通常不是最佳实践，因为它可能会隐藏你原本想要处理的特定异常）。
try:
# 尝试执行可能引发异常的代码
pass
except Exception as e:
# 捕获所有类型的异常
print(f"发生未知错误：{e}")9.5raise的用法
在Python中，raise语句用于手动触发一个异常。当程序执行到raise语句时，它会立即停止当前的代码执行，并向上层调用者抛出（或“触发”）一个异常。这个异常可以是Python内置的异常类型之一，也可以是自定义的异常类。如果异常没有被捕获处理，则程序将终止运行，并打印出一个错误信息。
基本用法：raise ExceptionType(args)
ExceptionType：是你要抛出的异常的类型。这可以是任何继承自Exception类的类，包括Python内置的异常类型和自定义的异常类。args：是传递给异常构造函数的参数，它将被转换成字符串并用作异常的描述信息。如果异常类型需要其他形式的参数，也可以相应地传递。
try:
pwd = input('请输入你的密码')
if len（pwd）<8:
raise Exception('密码长度不够，请输入一个8位以上的密码')
except Exception as e:
print(e)
#输入123
#控制台则打印密码长度不够，请输入一个8位以上的密码10、函数
Python中的函数是一种可重用的代码块，它接收一些输入（称为参数）并可能返回一些输出（称为返回值）。函数使得代码更加模块化，易于理解和维护。在Python中，你可以定义自己的函数来执行特定任务，也可以使用Python的内置函数和来自其他库的函数
10.1定义函数
在Python中，可以使用def关键字来定义一个函数。定义函数时，你需要指定函数名、参数列表（可能为空）以及函数体（即函数的代码块）
def function_name(parameter1, parameter2, ...):
"""
函数的文档字符串（可选）
描述函数的功能、参数和返回值。
"""
# 函数体
# 你可以在这里编写实现函数功能的代码
# 使用return语句可以返回一个值给调用者（可选）
return result10.2调用函数
定义函数后，你可以通过函数名加上圆括号（其中可以包含传递给函数的参数）来调用它。如果函数有返回值，则可以将返回值赋给一个变量，或者在其他表达式中使用它。
def add_numbers(a, b):
"""
计算并返回两个数的和。
参数:
a -- 第一个加数
b -- 第二个加数
返回:
两个数的和
"""
return a + b
# 调用函数
result = add_numbers(5, 3)
print(result) # 输出: 810.3参数与返回值
参数：函数可以定义零个或多个参数，这些参数在函数被调用时接收外部传入的值。
返回值：函数可以通过return语句返回一个值给调用者。如果函数没有return语句，或者return语句后面没有跟任何值，那么函数将返回None
10.4默认参数与关键字参数
默认参数：在定义函数时，你可以为参数指定默认值。如果在调用函数时没有为这些参数提供值，那么将使用默认值。
def greet(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet("Alice") # 输出: Hello, Alice!
greet("Bob", "Hi") # 输出: Hi, Bob!关键字参数：在调用函数时，你可以通过参数名来指定参数值，这称为关键字参数。使用关键字参数可以不必遵循函数定义中参数的顺序。
def person_info(name, age, job):
print(f"Name: {name}, Age: {age}, Job: {job}")
person_info(name="John", age=30, job="Engineer")
# 或者以不同的顺序（由于使用了关键字参数）
person_info(job="Doctor", name="Emily", age=25)10.5可变参数
Python还支持可变数量的参数，这在处理不确定数量的输入时非常有用。
*args：允许你将一个不定长度的参数列表传递给一个函数。def sum_numbers(*args): total = 0 for num in args: total += num return total print(sum_numbers(1, 2, 3, 4)) # 输出: 10**kwargs：允许你将不定长度的关键字参数传递给一个函数。def greet_person(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") greet_person(name="Alice", age=30, city="New York") # 输出: # name: Alice # age: 30 # city: New York10.6变量作用域
在Python中，函数变量作用域是一个非常重要的概念，它决定了变量在程序中的可见性和生命周期。Python中主要有三种作用域：局部作用域（Local Scope）、全局作用域（Global Scope）和内置作用域（Built-in Scope），但当我们讨论函数变量作用域时，主要关注的是局部作用域和全局作用域。
局部作用域是指变量在函数内部定义，并且只能在该函数内部被访问和修改。当函数被调用时，Python会创建一个新的局部命名空间，用来存储函数中定义的变量。这些变量在函数执行结束后将被销毁，除非它们被以某种方式（如返回值）传递到函数外部
全局作用域是指变量在函数外部定义，可以在整个模块（文件）中被访问和修改。在函数内部，如果你想访问或修改全局变量，你需要使用global关键字来声明该变量是全局的
def my_function():
x = "这是一个局部变量"
print(x)
my_function() # 输出: 这是一个局部变量
# print(x) # 如果用这个，这里就会引发NameError，因为x是局部作用域中的变量x = "这是一个全局变量"
def my_function():
print(x) # 访问全局变量
my_function() # 输出: 这是一个全局变量
def change_global():
global x
x = "全局变量已被修改"
change_global()
print(x) # 输出: 全局变量已被修改如果你尝试在函数内部修改全局变量但未使用global关键字，Python会创建一个同名的局部变量。
x = "这是一个全局变量"
def my_function():
x = "尝试修改但实际上是创建了局部变量"
print(x)
my_function() # 输出: 尝试修改但实际上是创建了局部变量
print(x) # 输出: 这是一个全局变量，全局变量未受影响10.7匿名函数
Python中的匿名函数是通过lambda关键字定义的简短函数。它们通常用于定义简单的、一次性的函数对象，这些对象可以作为参数传递给高阶函数（如map(), filter(), reduce()等）或者在需要函数对象的任何地方使用。由于lambda函数本质上是表达式，它们具有一个表达式，其结果自动成为函数的返回值。因此，lambda函数不能包含多个表达式、控制语句（如if-else、for循环等）或文档字符串
语法：
lambda arguments: expressionarguments是传递给函数的参数，可以有一个或多个，也可以没有（创建了一个不接受任何参数的函数）。expression是一个关于参数的表达式，计算该表达式的结果并将其返回。
示例：
square = lambda x: x * x
print(square(4)) # 输出: 16
#这里定义了一个名为square的lambda函数，它接受一个参数x并返回x的平方。numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]
#这里使用lambda函数作为map()函数的第一个参数。
#map()函数将lambda函数应用于numbers列表中的每个元素，
#并返回一个迭代器，该迭代器包含所有应用lambda函数后的结果。
#然后，使用list()函数将结果转换为列表。numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 输出: [2, 4, 6, 8, 10]10.8内置函数
Python提供了许多内置函数，这些函数可以直接使用，无需导入任何模块。它们通常用于执行常见的编程任务，如输入输出、数学运算、类型检查等。
# 使用内置函数len计算字符串的长度
s = "hello"
print(len(s)) # 输出: 5
# 使用内置函数print进行输出
print("Hello, World!")
# 使用内置函数max找出列表中的最大值
numbers = [1, 3, 5, 7, 9]
print(max(numbers)) # 输出: 9
# 使用内置函数type检查变量的类型
x = 5
print(type(x)) # 输出: <class 'int'>10.9递归函数
Python中的递归函数是一种特殊的函数，它会直接或间接地调用自身。递归函数是解决可以分解为相似子问题的问题的一种强大方法。在递归函数中，通常会有一个或多个基本情况（base case），即不需要进一步递归就能直接求解的情况。当函数遇到基本情况时，就会停止递归调用并返回结果。递归函数还需要有一个或多个递归步骤（recursive step），这些步骤会将问题分解为更小的子问题，直到达到基本情况。
阶乘是所有小于或等于该数的正整数的积，特别地，0的阶乘是1。阶乘是一个很好的递归函数示例。
def factorial(n):
# 基本情况
if n == 0:
return 1
# 递归步骤
else:
return n * factorial(n-1)
# 测试
print(factorial(5)) # 输出: 120factorial函数检查基本情况（n == 0），如果满足，则返回1。否则，它执行递归步骤，将问题分解为计算n-1的阶乘，然后将结果与n相乘。
斐波那契数列是一个经典的递归问题，其中每个数是前两个数的和，序列以0和1开始。
def fibonacci(n):
# 基本情况
if n <= 1:
return n
# 递归步骤
else:
return fibonacci(n-1) + fibonacci(n-2)
# 测试
print(fibonacci(10)) # 输出: 5511、模块
在Python中，模块是一个包含Python定义和声明的文件，文件名就是模块名加上.py后缀。模块允许你组织、封装代码，便于重用和维护。模块可以定义函数、类和变量，然后可以被其他模块或脚本导入（import）并使用。通俗讲，模块就好比是工具包，想使用这个工具包的工具，就需要导入import这个模块。
11.1导入模块
在Python中，你可以使用import语句来导入模块。有几种不同的导入方式
导入整个模块
import math
print(math.sqrt(16)) # 使用模块中的函数时，需要前缀模块名从模块中导入特定的函数或变量
from math import sqrt
print(sqrt(16)) # 直接使用函数名，无需模块名前缀为导入的模块或函数指定别名
import math as m
print(m.sqrt(16)) # 使用别名前缀
from math import sqrt as square_root
print(square_root(16)) # 使用别名导入模块中的所有内容（不推荐，因为可能导致命名冲突）
from math import *
print(sqrt(16))导入自定义创建模块
你可以创建自己的模块，只需将Python代码保存为.py文件即可。然后，你可以在其他Python脚本或模块中通过import语句来导入它。
例如，假设你有一个名为mymodule.py的文件，内容如下：
# mymodule.py
def greet(name):
print(f"Hello, {name}!")
my_variable = "This is a variable in mymodule."你可以在另一个Python文件中这样导入和使用它：
# another_script.py
from mymodule import greet
greet("Bob")
# 注意：my_variable 没有被导入，所以不能直接访问11.2包的使用
在Python中，包（Package）是一种高级的模块，它本质上是一个包含__init__.py文件的目录，这个目录可以包含模块（.py文件）和子包（即包含__init__.py的子目录）。包的主要作用是提供一种组织模块的方式，使得模块可以分组成相关的集合，从而更容易地管理和维护大型的项目。
包的作用
-
命名空间管理：包为模块提供了一个更细粒度的命名空间。通过使用包，你可以避免不同库中的模块名冲突。
-
代码组织：包允许你将相关的模块组织在一起，形成一个逻辑上更紧密的结构。这有助于项目的理解和维护。
-
分发与部署：包可以作为一个整体被分发和部署，使得其他开发者可以更容易地安装和使用你的代码。
-
封装与隐藏：通过
__init__.py文件，你可以控制哪些模块和子包被导入时自动加载，哪些则保持隐藏。
创建包
要创建一个包，你首先需要创建一个目录，并在该目录中放置一个名为__init__.py的文件。这个文件可以是空的，但它必须存在，因为它告诉Python这个目录应该被视为一个Python包。然后，你可以在这个目录中添加模块（.py文件）和子包（包含__init__.py的子目录）。
__init__.py文件可以包含初始化代码，也可以定义包级别的变量、函数或类。但是，它最常见的作用是作为包的标记文件，并且可能包含一些用于导入包中模块的import语句，以便简化包的外部使用。
导入包和包中的模块
11.3Python中的标准库
Python的标准库（Standard Library）是一组与Python解释器一起安装的模块集合，它提供了大量的预定义函数和类，用于执行常见的编程任务。简单说标准库就是Python官方提供给我们的一些很好用的工具包，我们可以直接调用。如文件操作、网络编程、文本处理、数据压缩、正则表达式匹配等。使用标准库可以极大地提高编程效率，避免重复造轮子
例如：
os 模块提供了与操作系统交互的功能，如文件路径操作、文件和目录管理、环境变量访问等。
sys 模块提供了一些变量和函数，用于操作Python运行时环境。
json 模块用于处理JSON数据。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成
re 模块提供了对正则表达式的支持。正则表达式是一种强大的文本处理工具，可以用于搜索、替换、匹配等操作。
datetime 模块提供了日期和时间的处理功能。
import os
# 获取当前工作目录
current_dir = os.getcwd()
print("当前工作目录:", current_dir)
# 列出当前目录下的所有文件和目录
for item in os.listdir(current_dir):
print(item)import sys
# sys.argv 是一个列表，包含了命令行参数
# sys.argv[0] 是脚本名，sys.argv[1:] 是传递给脚本的参数
print("脚本名:", sys.argv[0])
for arg in sys.argv[1:]:
print("参数:", arg)import json
# 字典转JSON字符串
data = {'name': 'John', 'age': 30, 'city': 'New York'}
json_str = json.dumps(data)
print("JSON字符串:", json_str)
# JSON字符串转字典
json_str = '{"name": "John", "age": 30, "city": "New York"}'
data = json.loads(json_str)
print("解析后的字典:", data)import re
# 假设我们要匹配的电话号码格式为：(xxx) xxx-xxxx
text = "Call me at (123) 456-7890 or (456) 789-1234"
phone_numbers = re.findall(r'\(\d{3}\) \d{3}-\d{4}', text)
print("电话号码:", phone_numbers)from datetime import datetime
now = datetime.now()
print("当前日期和时间:", now)
# 格式化日期和时间
formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
print("格式化后的日期和时间:", formatted_now)常见的标准库以及使用教程可以参考下面：
常见的标准库可以参考：python常用标准库_python标准库有哪些-CSDN博客
12、文件操作
12.1文件的基本概念
在Python中，文件是计算机存储设备上的一个序列化的数据结构，用于存储数据以供程序读取或写入。文件可以是文本文件，也可以是二进制文件，具体取决于文件中存储的数据类型。文件操作是编程中的一项基本任务，它允许程序与外部世界进行数据交换。
文件路径
文件路径是指向文件存储位置的字符串。在Python中，你可以使用绝对路径或相对路径来指定文件的位置。
- 绝对路径：从根目录（或某个固定点）开始的完整路径，如
C:\Users\Example\Documents\file.txt（Windows）或/home/user/Documents/file.txt（Linux/macOS）。 - 相对路径：相对于当前工作目录的路径。如果当前工作目录是
/home/user/Documents，那么file.txt就是相对于这个目录的相对路径。
文件模式
文件模式指定了文件应该如何被打开（只读、只写、追加等）以及文件是文本文件还是二进制文件。Python的open()函数使用模式参数来控制这些行为。常见的模式包括：
'r'：只读模式（默认）。如果文件不存在，抛出FileNotFoundError。'w'：只写模式。如果文件已存在，则覆盖；如果文件不存在，则创建新文件。'a'：追加模式。如果文件已存在，写入的数据会被追加到文件末尾；如果文件不存在，则创建新文件进行写入。'r+'、'w+'、'a+'：分别对应读写、读写（覆盖）、读写（追加）模式。'b'：二进制模式。可以与上述模式组合使用，如'rb'表示二进制只读模式。
文件对象
使用open()函数打开文件时，Python会返回一个文件对象。这个文件对象包含了文件的各种方法和属性，用于执行文件操作（如读取、写入、关闭文件等）。
文件指针
文件指针是一个抽象的概念，用于跟踪当前读写操作在文件中的位置。当你打开文件时，文件指针通常位于文件的开头。当你读取或写入文件时，文件指针会向前移动相应的字节数。你可以使用seek()方法来改变文件指针的位置，使用tell()方法来获取当前文件指针的位置。
缓冲区
文件操作通常涉及磁盘I/O，这是相对较慢的操作。为了提高性能，Python（和大多数操作系统）使用缓冲区来减少磁盘I/O的次数。当你写入文件时，数据首先被写入到缓冲区中，然后在某个时间点（如缓冲区满或显式调用flush()方法时）被写入到磁盘上。同样，当你从文件读取数据时，数据也是从磁盘读取到缓冲区中，然后从你的程序中读取。
文件编码
对于文本文件，Python需要知道文件的编码方式才能正确地将字节序列转换为字符串（在读取文件时）或将字符串转换为字节序列（在写入文件时）。默认情况下，Python使用系统默认的编码（如UTF-8），但你可以通过encoding参数在open()函数中指定其他编码方式。
文件关闭
完成文件操作后，应该使用close()方法关闭文件。关闭文件可以释放系统资源，并确保所有缓冲的输出都被正确写入文件。为了避免忘记关闭文件，可以使用with语句来自动管理文件的打开和关闭。
12.2读取文件
在Python中，读取文件是一个常见的操作，它允许你访问存储在文件中的信息。Python提供了多种方式来读取文件，包括一次性读取整个文件、逐行读取、以及按块读取等
使用open()函数打开文件
在读取文件之前，你需要使用open()函数以适当的模式（如'r'表示只读模式）打开文件。open()函数返回一个文件对象，该对象提供了多种方法来读取文件内容。
一次性读取整个文件
如果文件不是特别大，可以一次性将整个文件内容读取到内存中。这可以通过调用文件对象的read()方法来实现。
# 打开文件
with open('example.txt', 'r') as file:
# 一次性读取整个文件内容
content = file.read()
# 处理文件内容
print(content)逐行读取文件
对于大多数文本文件，逐行读取是一种更内存友好的方法。可以通过迭代文件对象来逐行读取文件，因为文件对象是可迭代的。
# 打开文件
with open('example.txt', 'r') as file:
# 逐行读取文件
for line in file:
# 处理每行内容
# 注意：每行末尾的换行符也会被读取，但通常不需要在打印时再次显示
print(line, end='') # 使用end=''来避免打印额外的换行符按块读取文件
如果需要更精细地控制读取过程，或者正在处理一个非常大的文件，你可能希望按块读取文件。这可以通过调用文件对象的read(size)方法来实现，其中size是你希望读取的字节数。
# 打开文件
with open('large_file.txt', 'r') as file:
# 设置块大小（例如，1024字节）
chunk_size = 1024
# 读取文件内容，直到文件末尾
while True:
# 读取一个块
chunk = file.read(chunk_size)
# 如果读取到空字符串，表示已经到达文件末尾
if not chunk:
break
# 处理块内容
# 注意：这里处理的是字节串，对于文本文件，你可能需要将其解码为字符串
# 例如：chunk_str = chunk.decode('utf-8')
# 但对于文本模式打开的文件，read()方法直接返回字符串，无需解码
print(chunk, end='') # 假设这里是文本模式，直接打印读取文件的其他注意事项
- 当使用
with语句打开文件时，文件会在with代码块执行完毕后自动关闭，这是一种很好的做法，因为它可以确保文件即使在发生异常时也能被正确关闭。 - 对于非文本文件（如图片、视频等），你应该以二进制模式（
'rb'）打开文件，并使用字节类型的数据进行处理。 - 读取大文件时，请考虑使用逐行读取或按块读取的方法，以避免消耗过多内存。
- 在处理文件时，请确保你有足够的权限来读取目标文件。
12.3写入文件
在Python中，写入文件是一个将数据保存到文件中的过程。这可以通过使用open()函数以写入模式（如'w'、'a'等）打开文件，并调用文件对象的write()或writelines()方法来实现。
使用open()函数打开文件
在写入文件之前，你需要使用open()函数以适当的模式打开文件。对于写入操作，常用的模式有：
'w'：写入模式，如果文件已存在则覆盖，如果文件不存在则创建新文件。'a'：追加模式，如果文件已存在则在文件末尾追加内容，如果文件不存在则创建新文件
# 以写入模式打开文件
with open('output.txt', 'w') as file:
# 写入内容
pass
# 以追加模式打开文件
with open('output.txt', 'a') as file:
# 追加内容
pass使用write()方法写入内容
write()方法用于将字符串写入文件。如果文件是以写入模式（'w'）打开的，并且文件已存在，则原有内容会被覆盖。如果文件是以追加模式（'a'）打开的，则写入的内容会被追加到文件末尾。
# 写入内容到文件
with open('output.txt', 'w') as file:
file.write('Hello, Python!\n')
file.write('This is a test file.\n')
# 追加内容到文件
with open('output.txt', 'a') as file:
file.write('Appending more text.\n')使用writelines()方法写入多行
如果你有一个字符串列表，并希望将它们全部写入文件，可以使用writelines()方法。但是，请注意，writelines()不会自动在字符串之间添加换行符，因此你可能需要在每个字符串末尾手动添加\n。
lines = ['First line.\n', 'Second line.\n', 'Third line.\n']
with open('output.txt', 'w') as file:
file.writelines(lines)写入二进制文件
对于非文本文件（如图片、视频等），你需要以二进制模式（'wb'或'ab'）打开文件，并使用字节类型的数据进行写入。
# 写入二进制数据到文件
data = b'\x89PNG\r\n\x1a\n...' # 假设这是PNG文件的头部
with open('image.png', 'wb') as file:
file.write(data)注意事项
- 当使用
with语句打开文件时，文件会在with代码块执行完毕后自动关闭，这是一种很好的做法，因为它可以确保文件即使在发生异常时也能被正确关闭。 - 写入文件时，请确保你有足够的权限来写入目标文件。
- 如果文件以写入模式（
'w'）打开，并且文件已存在，则原有内容会被覆盖。如果你不想覆盖原有内容，应该使用追加模式（'a'）。 - 对于文本文件，写入的内容应该是字符串类型。对于二进制文件，写入的内容应该是字节类型（
bytes）。 - 在写入文件时，如果文件非常大，请考虑分批写入，以避免消耗过多内存。但是，对于大多数情况，Python的文件写入操作是高效的，并且会自动处理内存管理。
12.4文件追加
文件追加与写入类似，但使用'a'模式打开文件时，如果文件已存在，写入的数据会被追加到文件末尾，而不是覆盖原有内容。
假设想在output.txt文件的末尾追加以下内容
Appending some more text.可以使用以下代码来实现：
# 向文件追加内容
with open('output.txt', 'a') as file:
file.write('Appending some more text.\n')注意事项
-
当使用
with语句时，文件会在with代码块执行完毕后自动关闭，无需显式调用close()方法。 - 读取文件时，如果文件很大，一次性读取整个文件可能会消耗大量内存。在这种情况下，可以逐行读取或使用
read(size)方法分块读取。 - 写入文件时，如果文件已存在且以
'w'模式打开，则原有内容会被覆盖。如果希望保留原有内容并追加新内容，请使用'a'模式。 - 对于二进制文件，应使用
'rb'、'wb'和'ab'模式进行读取、写入和追加操作，并使用字节类型的数据（如bytes对象）进行读写。
618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
