一. 解释器器的作用

1. Python解释器作用：运行文件
2. Python解释器种类： CPython，C语言开发的解释器[官方]，应用广泛的解释器。 IPython，基于CPython的一种交互式解释器。
3. 其他解释器： PyPy，基于Python语言开发的解释器。 Jython，运⾏行行在Java平台的解释器，直接把Python代码编译成Java字节码执行。 IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译 成.Net的字节码。

二.注释

注释的作用

注释的作用是用人类熟悉的语言对代码进行解释说明，方便后期维护。

注释的分类

• 单行注释： # 注释内容，快捷键 ctrl+/
• 多行注释：""" 注释内容 """ 或 ''' 注释内容 '''

解释器不执行注释内容。

三.变量

定义变量的语法

标识符：

• 由数字、字母、下划线组成
• 不能以数字开头
• 不能使用内置关键字
• 严格区分大小写

数据类型：

• 整型：int
• 浮点型：float
• 字符串：str
• 布尔型：bool
• 元组：tuple
• 集合：set
• 字典：dict
• 检测数据类型的方法：type()

四.输出及格式化输出

格式化输出即按照一定的格式输出内容。

1.格式化符号

• %s 字符串
• %d 有符号的十进制整数
• %f 浮点数
• %c 字符
• %u 无符号十进制整数
• %o 八进制整数
• %x 十六进制整数（小写ox）
• %X 十六进制整数（大写OX）
• %e 科学计数法（小写'e'）
• %E 科学计数法（大写'E'）
• %g %f和%e的简写
• %G %f和%E的简写

技巧

• %06d：表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出
• %.2f：表示小数点后显示的小数位数

2.体验

格式化字符串除了%s，还可以写为f'{表达式}'

age = 18 
name = 'TOM'
weight = 75.5
student_id = 1

# 我的名字是TOM
print('我的名字是%s' % name)
# 我的学号是0001
print('我的学号是%4d' % student_id)
# 我的体重是75.50公斤
print('我的体重是%.2f公斤' % weight)
# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))

3.f-格式化字符串

f-格式化字符串是Python 3.6中新增的格式化方法，该方法更简单易读。

4.转义字符

• \n：换行
• \t：制表符，一个tab键（4个空格）的距离

5.结束符

在Python中，print() 默认自带 end="\n" 这个换行结束符，所以导致每两个print之间会换行。用户可以按需求更改结束符。

• print结束符

6.示例

# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

# 更改print的结束符
print('输出的内容', end="\n")
print('内容', end="")

五.输入

输入功能

input('提示文字')

输入的特点：

1. 一般将input接收的数据存储到变量中。
2. input接收的任何数据默认都是字符串数据类型。

六.数据类型转换函数

七.运算符

1.算术运算符

*混合运算优先级顺序：()高于 ** 高于 / // % 高于 + -

2.赋值运算符

3.复合赋值运算符

4.比较运算符

比较运算符也叫关系运算符，通常用来判断。

5.逻辑运算符

数字之间的逻辑运算：

• and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
• or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字

八.条件语句

1. 简单的 if 语句

if 条件:
    # 条件成立时执行的代码

2. if...else...

if 条件:
    # 条件成立时执行的代码
else:
    # 条件不成立时执行的代码

3. 多重判断 (if...elif...else)

if 条件1:
    # 条件1成立时执行的代码
elif 条件2:
    # 条件2成立时执行的代码
else:
    # 以上条件都不成立时执行的代码

4. if 嵌套

if 条件1:
    # 条件1成立时执行的代码
    if 条件2:
        # 条件2也成立时执行的代码
        # ... 可以继续嵌套更多 if 语句

5. 三元运算符 (ternary operator)

在 Python 中，没有像其他语言（如 C++ 或 JavaScript）那样的传统三元运算符，但你可以使用条件表达式来达到类似的效果：

# 条件成立时执行的表达式 if 条件 else 条件不成立时执行的表达式
result = 表达式1 if 条件 else 表达式2

例如：

x = 10
y = "Positive" if x > 0 else "Non-positive"
print(y)  # 输出: Positive

在上面的代码中，y 的值将基于 x 的值来设置。如果 x > 0 为真，则 y 将被设置为 "Positive"；否则，它将被设置为 "Non-positive"。

九.循环

1.while 循环

while 循环用于在给定条件为真时重复执行代码块。

while 条件:
    # 条件成立时重复执行的代码1
    # 条件成立时重复执行的代码2
    # ...

# while 循环嵌套
while 条件1:
    # 条件1成立时执行的代码
    # ...
    while 条件2:
        # 条件2成立时执行的代码
        # ...
    # 条件2的循环结束后，继续条件1的循环
# 条件1的循环结束后，继续执行 while 循环之后的代码

2.for 循环

for 循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象，并对每个元素执行代码块。

for 临时变量 in 序列:
    # 重复执行的代码1
    # 重复执行的代码2
    # ...

# for 循环嵌套
for 外部变量 in 外部序列:
    # 外部循环的代码
    for 内部变量 in 内部序列:
        # 内部循环的代码
    # 内部循环结束后，继续外部循环的下一轮
# 外部循环结束后，继续执行 for 循环之后的代码

3.break 和 continue

• break：用于立即终止当前循环，不再执行循环中 break 之后的代码，并且跳出循环继续执行循环之后的代码。
• continue：用于跳过当前循环的剩余部分，立即开始下一次循环迭代。

4.else 子句

while 和 for 循环都可以配合 else 子句使用。当循环正常结束（即没有通过 break 退出）时，会执行 else 子句中的代码。

while 条件:
    # 循环体
    if 某个条件:
        break  # 终止循环，不会执行 else 子句
else:
    # 当循环正常结束时执行的代码

for 变量 in 序列:
    # 循环体
    if 某个条件:
        continue  # 跳过当前迭代，继续下一次循环，不影响 else 子句的执行
else:
    # 当循环正常结束时执行的代码

注意：如果循环是通过 break 退出的，则不会执行 else 子句中的代码。如果循环是因为条件不再满足而自然结束的，则会执行 else 子句中的代码。

十.字符串

Python中的字符串（string）是由一串字符组成的不可变序列。字符串可以通过单引号（'）、双引号（"）、三引号（'''或"""）定义。下面是一些基本的字符串定义方式：

# 单引号
str1 = 'Hello, World!'

# 双引号
str2 = "Hello, World!"

# 三引号（可以跨越多行）
str3 = '''Hello,
World!'''

str4 = """Hello,
World!"""

常用字符串方法

Python 提供了丰富的字符串处理方法，以下是一些常用的方法：

1. 长度获取

   s = "Hello, World!"
   length = len(s)  # 返回字符串的长度
   

2. 字符串拼接

   s1 = "Hello"
   s2 = "World"
   s = s1 + ", " + s2 + "!"  # 拼接字符串
   

3. 重复字符串

   s = "Hello! " * 3  # 重复字符串三次
   

4. 查找子字符串

   s = "Hello, World!"
   index = s.find("World")  # 返回子字符串的起始索引，如果不存在则返回-1
   index = s.index("World")  # 返回子字符串的起始索引，如果不存在则抛出异常
   

5. 替换子字符串

   s = "Hello, World!"
   s = s.replace("World", "Python")  # 替换子字符串
   

6. 分割字符串

   s = "Hello, World!"
   parts = s.split(", ")  # 以逗号和空格为分隔符分割字符串，返回列表
   

7. 去除空白字符

   s = "  Hello, World!  "
   s = s.strip()  # 去除两边的空白字符
   s = s.lstrip()  # 去除左边的空白字符
   s = s.rstrip()  # 去除右边的空白字符
   

8. 大小写转换

   s = "Hello, World!"
   s_lower = s.lower()  # 转换为小写
   s_upper = s.upper()  # 转换为大写
   s_title = s.title()  # 转换为标题格式
   s_capitalize = s.capitalize()  # 首字母大写，其余小写
   

9. 检查字符串

   s = "Hello123"
   is_alpha = s.isalpha()  # 判断是否全为字母
   is_digit = s.isdigit()  # 判断是否全为数字
   is_alnum = s.isalnum()  # 判断是否全为字母和数字
   is_space = s.isspace()  # 判断是否全为空白字符
   

10. 格式化字符串

    name = "Alice"
    age = 30
    s = f"My name is {name} and I am {age} years old."  # 使用f-string进行格式化
    s = "My name is {} and I am {} years old.".format(name, age)  # 使用format方法进行格式化
    s = "My name is %s and I am %d years old." % (name, age)  # 使用百分号进行格式化
    

11. 字符串对齐

    s = "Hello"
    s_center = s.center(20, '*')  # 居中对齐，填充字符为*
    s_left = s.ljust(20, '*')  # 左对齐
    s_right = s.rjust(20, '*')  # 右对齐
    

12. 字符串判断

    s = "Hello, World!"
    starts_with = s.startswith("Hello")  # 判断是否以指定子字符串开头
    ends_with = s.endswith("World!")  # 判断是否以指定子字符串结尾
    

13. 字符串的索引和切片

• 索引（Index）：通过索引可以访问字符串中的单个字符。在Python中，索引是从0开始的。

s = 'hello'
print(s[0])  # 输出 'h'
print(s[4])  # 输出 'o'

• 切片（Slicing）：切片用于访问字符串的一个子串。切片操作的基本语法是 [start:stop:step]。

s = 'hello'
print(s[1:4])  # 输出 'ell'
print(s[::2])  # 输出 'hlo'，每隔一个字符取一个
print(s[::-1]) # 输出 'olleh'，反向切片

14. 字符串的常用方法

• find()：查找子串在字符串中首次出现的位置，如果未找到则返回-1。

s = 'hello world'
print(s.find('world'))  # 输出 6

• replace()：替换字符串中的子串。

s = 'hello world'
print(s.replace('world', 'Python'))  # 输出 'hello Python'

• split()：通过指定分隔符将字符串分割成子串列表。

s = 'apple,banana,orange'
print(s.split(','))  # 输出 ['apple', 'banana', 'orange']

• join()：将列表中的字符串按照指定分隔符连接成一个新的字符串。

lst = ['apple', 'banana', 'orange']
print(','.join(lst))  # 输出 'apple,banana,orange'

• strip()：去除字符串首尾的空白字符（包括空格、换行符等）。

s = '   hello world   '
print(s.strip())  # 输出 'hello world'

• upper() 和 lower()：将字符串中的所有字符转换为大写或小写。

s = 'Hello World'
print(s.upper())  # 输出 'HELLO WORLD'
print(s.lower())  # 输出 'hello world'

• startswith() 和 endswith()：检查字符串是否以指定的前缀或后缀开始或结束。

s = 'hello world'
print(s.startswith('hello'))  # 输出 True
print(s.endswith('world'))    # 输出 True

• len()：返回字符串的长度（字符数）。

s = 'hello'
print(len(s))  # 输出 5

十一.列表

1.列表的格式

列表（List）在Python中是一种有序的数据集合，用于存储一系列的元素。列表中的元素可以是任何类型，包括数字、字符串、列表（嵌套列表）等。列表用方括号[]表示，元素之间用逗号,分隔。

示例：

[数据1, 数据2, 数据3]

2.常用的操作方法

列表提供了许多内置的方法来操作元素，包括：

• index(value): 返回指定值在列表中的索引，如果值不存在则抛出ValueError。
• len(list): 返回列表的长度，即列表中元素的个数。
• append(value): 在列表的末尾添加一个新的元素。
• pop([index]): 移除列表中的一个元素（默认是最后一个元素），并返回它。如果指定了索引，则移除该索引处的元素。
• remove(value): 从列表中移除第一个出现的指定值。如果值不存在则抛出ValueError。

3.列表嵌套

列表可以嵌套，即列表中的元素可以是另一个列表。这允许我们创建更复杂的数据结构。

示例：

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]

在这个嵌套列表中，name_list 是一个包含三个元素的列表，每个元素本身也是一个列表，分别包含三个名字。

4.访问嵌套列表中的元素

要访问嵌套列表中的元素，你需要使用多个索引。例如，要访问 name_list 中第三个列表（索引为2）中的第二个元素（索引为1），你可以这样做：

print(name_list[2][1])  # 输出 '李四'

这里，name_list[2] 首先获取到第三个子列表 ['张三', '李四', '王五']，然后 [1] 获取到这个子列表中的第二个元素 '李四'。

十二.元组

Python中的元组（Tuple）是一种不可变（immutable）的有序序列类型，用于存储一系列的元素。与列表（List）相似，元组也使用圆括号()来表示，但是元组一旦创建，其内容就不能被修改（即不能添加、删除或修改元素）。

1.创建元组

元组可以使用圆括号()来创建，元素之间用逗号,分隔。如果元组只有一个元素，那么需要在元素后面添加一个逗号，以区分该元素和圆括号本身。

# 创建一个包含多个元素的元组
my_tuple = (1, 2, 3, 4, 5)

# 创建一个只包含一个元素的元组
single_element_tuple = (1,)  # 注意这里的逗号

# 也可以不使用圆括号，但通常为了明确是元组，还是加上圆括号
another_tuple = 1, 2, 3

# 元组也可以包含不同类型的元素
mixed_tuple = ('apple', 42, 3.14, True)

2.访问元组元素

可以使用索引来访问元组中的元素，索引从0开始。

# 访问元组中的元素
print(my_tuple[0])  # 输出 1
print(my_tuple[2])  # 输出 3

3.元组切片

与列表一样，元组也支持切片操作。

# 切片操作
print(my_tuple[1:4])  # 输出 (2, 3, 4)

4.元组的方法

由于元组是不可变的，所以它只有少数几个方法，主要是用于查询操作。

• count(value): 返回元组中指定元素出现的次数。
• index(value): 返回元组中指定元素第一次出现的索引，如果元素不存在则抛出ValueError。

# 使用元组的方法
print(my_tuple.count(3))  # 输出 1
print(my_tuple.index(2))  # 输出 1

5.元组的用途

元组由于其不可变性的特性，在需要保护数据不被意外修改的场景中特别有用。例如，在定义函数参数默认值时，如果参数是列表，则每次调用函数时都会修改该列表，而使用元组作为默认值则不会。此外，元组还常用在需要快速访问其元素且不需要修改的场景中，因为它们比列表更节省内存，并且由于是不可变的，所以在多线程环境中也是安全的。

十三.集合

Python中的集合（Set）是一个无序且不包含重复元素的集合类型。集合通常用于进行成员检测、去除重复元素以及集合运算（如交集、并集、差集等）。

1.创建集合

集合可以使用大括号{}或者set()函数来创建。但请注意，如果使用大括号{}来创建集合，并且集合内没有元素，那么需要使用set()函数来避免与字典的创建混淆。

# 使用大括号创建集合
my_set1 = {1, 2, 3, 4, 5}

# 使用set()函数创建集合
my_set2 = set([1, 2, 2, 3, 4, 4, 5])  # 注意重复元素会被自动去除

# 创建一个空集合（注意不能仅使用{}，这会创建一个空字典）
empty_set = set()

2.访问集合元素

由于集合是无序的，因此不能通过索引来访问集合中的元素。但是可以使用循环来遍历集合中的所有元素。

for item in my_set1:
    print(item)

3.集合的常用方法

集合提供了许多内置的方法来操作元素，包括添加、删除、检查成员资格以及集合运算等。

• add(element): 添加一个元素到集合中。
• update(iterable): 将另一个集合或可迭代对象的所有元素添加到当前集合中。
• remove(element): 从集合中移除一个元素（如果元素不存在则抛出KeyError）。
• discard(element): 从集合中移除一个元素（如果元素不存在则不抛出异常）。
• pop(): 随机移除并返回集合中的一个元素（如果集合为空则抛出KeyError）。
• clear(): 移除集合中的所有元素。
• isdisjoint(other_set): 检查两个集合是否有交集，如果没有交集则返回True。
• issubset(other_set) 或 __le__(other_set): 检查当前集合是否是另一个集合的子集。
• issuperset(other_set) 或 __ge__(other_set): 检查当前集合是否是另一个集合的超集。
• union(other_set) 或 |: 返回两个集合的并集。
• intersection(other_set) 或 &: 返回两个集合的交集。
• difference(other_set) 或 -: 返回集合的差集，即属于当前集合但不属于另一个集合的元素。
• symmetric_difference(other_set) 或 ^: 返回两个集合的对称差集，即属于当前集合或另一个集合但不属于它们的交集的元素。

4.示例

# 创建集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 集合运算
print(set1.union(set2))       # {1, 2, 3, 4, 5, 6}
print(set1.intersection(set2)) # {3, 4}
print(set1.difference(set2))  # {1, 2}
print(set1.symmetric_difference(set2)) # {1, 2, 5, 6}

# 添加和删除元素
set1.add(5)
print(set1)  # {1, 2, 3, 4, 5}
set1.remove(3)
print(set1)  # {1, 2, 4, 5}

# 检查成员资格
if 2 in set1:
    print("2 is in the set.")

十四.字典

Python中的字典（Dictionary）是一种无序的、可变的数据结构，用于存储键值对（key-value pairs）。字典使用花括号{}表示，键（key）和值（value）之间用冒号:分隔，不同的键值对之间用逗号,分隔。

1.创建字典

# 创建一个空字典
empty_dict = {}

# 创建一个包含键值对的字典
person = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 也可以直接使用键值对来创建字典
another_dict = {'country': 'USA', 'population': 330e6}

2.访问字典元素

通过键来访问字典中的值。

# 访问字典中的值
print(person['name'])  # 输出 'Alice'
print(person['age'])   # 输出 30

如果尝试访问不存在的键，Python会抛出一个KeyError异常。为了避免这种情况，可以使用get()方法，该方法在键不存在时返回None或指定的默认值。

# 使用get()方法避免KeyError
print(person.get('name'))  # 输出 'Alice'
print(person.get('job'))   # 输出 None
print(person.get('job', 'Unknown'))  # 输出 'Unknown'

3.修改字典

可以通过为键赋值来修改字典中的值。

# 修改字典中的值
person['age'] = 31
print(person)  # 输出 {'name': 'Alice', 'age': 31, 'city': 'New York'}

4.添加键值对

如果键不存在于字典中，可以通过直接为键赋值来添加键值对。

# 添加键值对
person['job'] = 'Engineer'
print(person)  # 输出 {'name': 'Alice', 'age': 31, 'city': 'New York', 'job': 'Engineer'}

5.删除键值对

可以使用del语句或pop()方法删除字典中的键值对。

# 使用del语句删除键值对
del person['job']
print(person)  # 输出 {'name': 'Alice', 'age': 31, 'city': 'New York'}

# 使用pop()方法删除键值对并返回其值
job = person.pop('city')
print(person)  # 输出 {'name': 'Alice', 'age': 31}
print(job)     # 输出 'New York'

如果尝试使用pop()方法删除不存在的键，Python会抛出一个KeyError异常。为了避免这种情况，可以提供一个默认值作为pop()方法的第二个参数。

# 使用pop()方法并指定默认值
occupation = person.pop('occupation', 'Unknown')
print(occupation)  # 输出 'Unknown'

6.字典的方法

字典有许多内置的方法，包括keys()、values()、items()等，用于获取字典的键、值或键值对。

# 获取字典的键、值和键值对
print(person.keys())       # 输出 dict_keys(['name', 'age'])
print(person.values())     # 输出 dict_values(['Alice', 31])
print(person.items())      # 输出 dict_items([('name', 'Alice'), ('age', 31)])

# 注意，keys()、values()和items()返回的是视图对象，可以使用list()转换为列表
print(list(person.keys()))  # 输出 ['name', 'age']

9.字典的遍历

可以遍历字典的键、值或键值对。

# 遍历字典的键
for key in person:
    print(key)

# 遍历字典的值
for value in person.values():
    print(value)

# 遍历字典的键值对
for key, value in person.items():
    print(key, value)

十五.公共操作及方法

1.公共运算符

2.公共方法

十六.推导式

Python中的推导式（comprehension）是一种简洁地构造容器（如列表、元组、字典和集合）的方法。它允许你在一行代码中完成复杂的操作，使得代码更加简洁和易读。Python中有两种主要的推导式：列表推导式（list comprehension）和字典推导式（dictionary comprehension），Python 3.7及以后版本还引入了集合推导式（set comprehension）和生成器表达式（generator expression）。

1.列表推导式（List Comprehension）

列表推导式是生成列表的一种简洁方式。基本语法如下：

[expression for item in iterable if condition]

其中expression是对item进行操作的表达式，iterable是一个可迭代对象（如列表、元组、字符串、集合或字典等），condition是一个可选的条件表达式，用于筛选item。

示例：

# 创建一个包含0到9的平方的列表
squares = [x**2 for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 创建一个包含列表中所有偶数平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出: [0, 4, 16, 36, 64]

2.字典推导式（Dictionary Comprehension）

字典推导式用于创建字典。基本语法如下：

{key_expression: value_expression for item in iterable if condition}

其中key_expression和value_expression分别用于计算字典的键和值，iterable是一个可迭代对象，condition是一个可选的条件表达式。

示例：

# 创建一个字典，键是0到4的数字，值是对应数字的平方
squares_dict = {x: x**2 for x in range(5)}
print(squares_dict)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 创建一个字典，键是列表中字符串的长度，值是字符串本身
words = ['apple', 'banana', 'cherry']
lengths_dict = {len(word): word for word in words}
print(lengths_dict)  # 输出可能因Python版本和哈希随机化而不同，但通常类似于 {5: 'apple', 6: 'banana', 6: 'cherry'}（注意重复的键会被覆盖）

3.集合推导式（Set Comprehension）

集合推导式用于创建集合。基本语法与列表推导式类似，但使用大括号{}（不带条件时为集合，带条件时可能因歧义而需要转换为set()函数调用）：

{expression for item in iterable if condition}
# 或者当存在歧义时
set(expression for item in iterable if condition)

示例：

# 创建一个包含0到9中所有偶数的集合
even_numbers = {x for x in range(10) if x % 2 == 0}
print(even_numbers)  # 输出: {0, 2, 4, 6, 8}

4.生成器表达式（Generator Expression）

生成器表达式与列表推导式类似，但返回的是一个生成器对象，而不是一次性生成整个列表。生成器表达式使用小括号()而不是方括号[]。

示例：

# 创建一个生成器，用于生成0到9的平方
squares_generator = (x**2 for x in range(10))
for square in squares_generator:
    print(square)  # 依次输出0到81的平方

生成器表达式在需要逐个处理元素而不是一次性处理整个列表时特别有用，因为它们更加内存高效。

十七.函数

1.函数的作用：封装代码，高效的代码重用

2.函数使用步骤：

定义函数

def 函数名():
    代码1
    代码2
    ...

调用函数

函数名()

3.函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性

• 形参：函数定义时书写的参数（非真实数据）
• 实参：函数调用时书写的参数（真实数据）

4.函数的返回值：

• 作用：函数调用后，返回需要的计算结果
• 写法：

  return 表达式
  

5.函数的说明文档：

• 作用：保存函数解释说明的信息
• 写法：

  def 函数名():
      """ 函数说明文档 """
      代码...
  

6.函数嵌套调用：一个函数内部嵌套调用另外一个函数

7.变量作用域：

• 全局：在函数体外定义的变量，函数体内外都能访问和修改（除非在函数体内被声明为局部变量）。
• 局部：在函数体内定义的变量，只在当前函数体内部有效。当函数执行完毕后，局部变量就会被销毁。

函数多返回值写法：

在Python中，函数可以通过return语句返回多个值，这些值会被收集到一个元组中。

def multiple_return_values():
    return 1, 2, 3

a, b, c = multiple_return_values()
print(a, b, c)  # 输出：1 2 3

8.函数的参数：

1. 位置参数（Positional Arguments）：

   • 形参和实参的个数和书写顺序必须一致。

2. 关键字参数（Keyword Arguments）：

   • 写法：key=value
   • 特点：形参和实参的书写顺序可以不一致；关键字参数必须书写在位置参数的后面。

3. 缺省参数（Default Parameters）：

   • 缺省参数就是默认参数，当调用函数时没有提供该参数的值时，将使用默认值。
   • 写法：在定义函数时，为参数指定默认值，如def func(a, b=2): ...。

4. 不定长位置参数（Variable Positional Arguments）：

   • 收集所有位置参数，返回一个元组。
   • 写法：在形参列表中使用*args。

5. 不定长关键字参数（Variable Keyword Arguments）：

   • 收集所有关键字参数，返回一个字典。
   • 写法：在形参列表中使用**kwargs。

9.Python中数据的传递：

在Python中，数据的传递都是通过引用进行的，但这并不意味着Python总是直接操作原始数据的引用。对于不可变类型（如整数、浮点数、字符串、元组等），当你“传递”这些类型的数据时，实际上是在传递这些数据的值的一个引用（尽管这些值是不可变的）。而对于可变类型（如列表、字典、集合等），传递的是对这些可变对象的引用，这意味着函数内部对这些对象的修改会影响到函数外部的对象状态。

不过，需要注意的是，在函数内部对不可变类型的变量进行重新赋值（即指向新的对象），并不会影响到函数外部对该变量的引用。而对于可变类型，由于传递的是引用，所以在函数内部对可变对象的修改会反映到函数外部。

10.递归

递归函数指的是在函数内部调用自身的函数。使用递归函数时，必须确保有一个或多个退出条件，以防止无限递归。

11.Lambda 表达式

Lambda 表达式是一种创建匿名函数的语法，其基本形式为：lambda 参数列表: 表达式。

Lambda 参数形式

• 无参数：lambda: 表达式
• 一个参数：lambda 参数: 表达式
• 默认参数：lambda key=value: 表达式（注意：尽管 Python 的 lambda 表达式本身不支持默认参数，但这里为了说明其概念性结构，进行了示意）
• 不定长位置参数：lambda *args: 表达式（注意：同样地，Python 的 lambda 表达式本身不支持这种形式，但为了完整性这里进行说明）
• 不定长关键字参数：lambda **kwargs: 表达式（同样地，lambda 不直接支持这种形式）

12.高阶函数

高阶函数是指接受函数作为参数，或者返回函数作为结果的函数。高阶函数的作用通常是用于简化代码结构，提高代码的可读性和可重用性。

Python 中有很多内置的高阶函数，如：

• map()：接受一个函数和多个列表作为参数，返回一个迭代器，该迭代器将函数应用于每个列表的元素，并返回应用结果。
• reduce()：对序列进行累积操作，需要传入两个参数，一个二元操作函数和一个序列，序列的每个元素依次传入二元操作函数中进行计算。
• filter()：使用指定的函数过滤序列中的元素，返回由该函数返回值为 True 的元素组成的迭代器。

十八.文件操作

Python 提供了丰富的文件操作功能，可以用来读写各种类型的文件。以下是一些基本的文件操作和相关示例：

1.文件打开模式

在打开文件时，可以指定不同的模式：

• 'r'：读模式（默认模式）。文件必须存在，否则会报错。
• 'w'：写模式。文件不存在会创建文件，文件存在会清空文件内容。
• 'a'：追加模式。文件不存在会创建文件，文件存在则在文件末尾追加内容。
• 'b'：二进制模式。与其他模式结合使用，比如 'rb'， 'wb'。
• '+'：读写模式。与其他模式结合使用，比如 'r+'， 'w+'， 'a+'。

2.基本文件操作

1.打开和关闭文件

file = open('example.txt', 'r')
# 进行文件操作
file.close()

为了避免忘记关闭文件，可以使用 with 语句，这样会在操作结束后自动关闭文件：

with open('example.txt', 'r') as file:
    # 进行文件操作
    content = file.read()

2.读取文件

读取整个文件内容：

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='')

读取特定数量的字符：

with open('example.txt', 'r') as file:
    content = file.read(10)  # 读取前10个字符
    print(content)

3.写入文件

覆盖写入文件：

with open('example.txt', 'w') as file:
    file.write('This is a new line.\n')

追加写入文件：

with open('example.txt', 'a') as file:
    file.write('This is an appended line.\n')

写入多个行：

lines = ['First line.\n', 'Second line.\n', 'Third line.\n']
with open('example.txt', 'w') as file:
    file.writelines(lines)

3.处理二进制文件

读取二进制文件：

with open('example.png', 'rb') as file:
    content = file.read()
    print(content[:10])  # 打印前10个字节

写入二进制文件：

with open('example_copy.png', 'wb') as file:
    file.write(content)

4.文件定位与操作

获取文件当前读取位置：

with open('example.txt', 'r') as file:
    file.read(10)
    position = file.tell()
    print(position)

移动文件指针：

with open('example.txt', 'r') as file:
    file.seek(5)
    content = file.read()
    print(content)

5.文件与目录操作

使用 os 和 shutil 模块进行文件和目录操作：

import os
import shutil

# 重命名文件
os.rename('old_name.txt', 'new_name.txt')

# 删除文件
os.remove('file_to_delete.txt')

# 创建目录
os.mkdir('new_directory')

# 删除目录
os.rmdir('empty_directory')

# 拷贝文件
shutil.copy('source.txt', 'destination.txt')

# 拷贝目录
shutil.copytree('source_directory', 'destination_directory')

# 删除目录及其内容
shutil.rmtree('directory_to_delete')

6.示例代码

以下是一个完整的示例代码，展示了如何创建一个文件，写入内容，读取内容，并进行文件操作：

import os

# 创建并写入文件
with open('example.txt', 'w') as file:
    file.write('Hello, World!\n')
    file.write('This is a test file.\n')

# 读取文件内容
with open('example.txt', 'r') as file:
    content = file.read()
    print('File content:')
    print(content)

# 获取文件信息
file_size = os.path.getsize('example.txt')
print(f'File size: {file_size} bytes')

# 重命名文件
os.rename('example.txt', 'renamed_example.txt')

# 删除文件
os.remove('renamed_example.txt')

十九.Python面向对象基础

面向对象编程的重要组成部分主要包括：类（Class）和对象（Object）。以下是整理后的文字格式，包含了创建类、添加对象属性、获取对象属性和魔法方法的说明：

1.类（Class）

类是对象的模板或蓝图，它定义了一组具有相同属性和方法的对象的集合。

class 类名:
    # 类的定义区域
    def __init__(self, 参数列表):
        # 初始化方法，用于设置对象的初始状态
        self.属性名 = 值
    
    def 方法名(self, 其他参数):
        # 类的方法，用于定义对象的行为
        # 方法内部可以通过self访问对象的属性和其他方法
        pass

    # 其他方法...

# 创建类的一个实例（对象）
对象名 = 类名(参数值)

2.对象（Object）

对象是类的实例化，它拥有类定义的属性和方法。

1.添加对象属性

在类外部：

对象名.属性名 = 值

在类内部（通常在__init__方法中）：

self.属性名 = 值

2.获取对象属性

在类外部：

值 = 对象名.属性名

在类内部（如方法内部）：

值 = self.属性名

3.魔法方法（Magic Methods）

魔法方法是Python中一些以双下划线开头和结尾的特殊方法，它们在特定情况下被Python自动调用。

• __init__(self, ...): 初始化方法，当创建对象时自动调用。
• __str__(self): 返回对象的字符串表示，常用于print函数。
• __del__(self): 析构方法，当对象被销毁时自动调用。

示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"
    
    def __del__(self):
        print(f"Person {self.name} is being deleted.")

# 创建对象
person = Person("Alice", 30)

# 获取属性
print(person.name)  # 输出: Alice

# 输出对象信息
print(person)  # 输出: Person(name=Alice, age=30)，因为调用了__str__方法

# 删除对象（通常Python会自动管理内存，但你可以显式地删除对象）
del person  # 输出: Person Alice is being deleted.，因为调用了__del__方法

注意：__del__ 方法在Python的垃圾回收机制中并不总是会被调用，因为Python使用引用计数和循环垃圾回收器来管理内存。在大多数情况下，你不需要（也不应该）在类中定义__del__方法，除非你有特定的资源清理需求。

4.继承

1.继承的特点

1. 子类默认拥有父类的所有属性和方法

   • 当一个类继承另一个类时，子类自动拥有父类中的所有公共属性和方法，无需重新定义。

2. 子类重写父类同名方法和属性

   • 子类可以重写（覆盖）父类中的同名方法和属性，以提供特定的实现。

3. 子类调用父类同名方法和属性

   • 子类可以通过 super() 方法来调用父类的同名方法和属性，从而扩展或修改父类的方法。

4. super() 方法快速调用父类方法

   • 使用 super() 可以方便地调用父类的方法，尤其是在重写方法时，需要保留父类的一部分行为。

2.私有权限

• 不能继承给子类的属性和方法需要添加私有权限
  • 如果不希望某些属性和方法被子类继承，可以将其定义为私有（以双下划线 __ 开头）。

3.语法

定义类和私有属性、方法

class 类名:
    # 私有属性
    __属性名 = 值

    # 私有方法
    def __私有方法(self):
        pass

4.详细示例

定义父类和子类

class 父类:
    def __init__(self, 公共属性, 私有属性):
        self.公共属性 = 公共属性
        self.__私有属性 = 私有属性

    def 公共方法(self):
        print("这是父类的公共方法")

    def __私有方法(self):
        print("这是父类的私有方法")

    def 获取私有属性(self):
        return self.__私有属性

class 子类(父类):
    def __init__(self, 公共属性, 私有属性, 新属性):
        super().__init__(公共属性, 私有属性)
        self.新属性 = 新属性

    def 公共方法(self):
        print("这是子类重写的公共方法")

    def 调用父类方法(self):
        super().公共方法()

# 实例化子类
子类实例 = 子类("公共属性值", "私有属性值", "新属性值")

# 调用子类的方法
子类实例.公共方法()  # 输出: 这是子类重写的公共方法
子类实例.调用父类方法()  # 输出: 这是父类的公共方法

# 尝试访问私有属性和方法
print(子类实例.获取私有属性())  # 输出: 私有属性值
# 子类实例.__私有方法()  # 这行代码会报错，因为私有方法不能被直接访问

解释

1. 子类默认拥有父类的所有属性和方法

   • 子类实例 子类实例 继承了父类的 公共属性 和 公共方法。

2. 子类重写父类同名方法和属性

   • 子类通过定义同名的 公共方法 重写了父类的 公共方法。

3. 子类调用父类同名方法和属性

   • 子类中的 调用父类方法 使用 super().公共方法() 调用了父类的 公共方法。

4. super() 方法快速调用父类方法

   • super() 被用来在子类方法中调用父类的方法。

5. 私有权限

   • 私有属性和方法（以 __ 开头）不能被子类直接访问，但可以通过公共方法 获取私有属性 来间接访问私有属性。

5.⾯向对象三⼤特性

封装
继承
多态

6.类属性

归属于类对象的属性，所有对象共有的属性

7.实例例属性

8.类⽅法

@classmethod
def xx():
    # 代码

9.静态⽅法

@staticmethod
def xx():
    # 代

10.异常

Python 提供了一个强大的异常处理机制，用于捕获和处理运行时错误。以下是关于 Python 异常的详细介绍：

1.异常的基本概念

异常 是指程序运行过程中出现的错误情况，例如试图打开一个不存在的文件、除零错误、访问不存在的变量等。Python 提供了多种内置异常类，可以在这些错误发生时进行处理。

2.常见的内置异常

• Exception: 所有异常的基类
• AttributeError: 试图访问一个对象没有的属性
• IOError: 输入输出操作失败
• ImportError: 导入模块失败
• IndexError: 序列中没有此索引
• KeyError: 字典中没有此键
• KeyboardInterrupt: 用户中断执行（通常是输入^C）
• NameError: 使用一个还未被赋予对象的变量
• OSError: 操作系统错误
• TypeError: 传入对象类型与要求的不符
• ValueError: 传入值与要求的不符
• ZeroDivisionError: 除数为零

3.捕获异常

使用 try 和 except 语句来捕获和处理异常：

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除零错误")

4.多个 except 块

可以在一个 try 语句中处理多种异常：

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除零错误")
except TypeError:
    print("类型错误")

5.捕获所有异常

可以捕获所有异常，但这样做可能会掩盖真正的问题：

try:
    result = 10 / 0
except Exception as e:
    print(f"发生异常: {e}")

6.else 子句

try 块中没有异常时执行 else 块：

try:
    result = 10 / 2
except ZeroDivisionError:
    print("除零错误")
else:
    print(f"结果是 {result}")

7.finally 子句

无论是否发生异常，finally 块总会执行：

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除零错误")
finally:
    print("执行完毕")

8.自定义异常

可以通过继承 Exception 类来自定义异常：

class CustomError(Exception):
    pass

try:
    raise CustomError("这是一个自定义错误")
except CustomError as e:
    print(f"捕获到自定义异常: {e}")

9.异常链

通过 raise 语句重新引发异常，保留上下文：

try:
    try:
        result = 10 / 0
    except ZeroDivisionError as e:
        raise ValueError("重新引发一个异常") from e
except ValueError as e:
    print(f"捕获到异常: {e}")

10.示例代码

以下是一个综合示例，展示了如何捕获和处理不同类型的异常：

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("除零错误")
    except TypeError:
        print("类型错误")
    else:
        print(f"结果是 {result}")
    finally:
        print("执行完毕")

# 测试
divide(10, 2)   # 正常情况
divide(10, 0)   # 除零错误
divide(10, "a") # 类型错误

通过这些机制，Python 提供了灵活且强大的异常处理功能，确保程序能够在面对错误时优雅地处理。

11.模块和包

在 Python 中，模块和包是用于组织代码的结构，使得代码更加可读、可维护和可复用。以下是关于 Python 模块和包的详细介绍：

1.模块

模块 是一个包含 Python 定义和语句的文件，文件名以 .py 结尾。模块可以定义函数、类和变量，也可以包含可执行的代码。

创建模块

创建一个简单的模块 mymodule.py：

# mymodule.py

def greet(name):
    return f"Hello, {name}!"

class Person:
    def __init__(self, name):
        self.name = name

    def say_hello(self):
        return f"{self.name} says hello!"

导入模块

可以使用 import 语句导入模块，并使用模块中的函数和类：

import mymodule

print(mymodule.greet("Alice"))

person = mymodule.Person("Bob")
print(person.say_hello())

导入特定的函数或类

可以使用 from ... import ... 语句导入模块中的特定部分：

from mymodule import greet, Person

print(greet("Alice"))

person = Person("Bob")
print(person.say_hello())

模块搜索路径

当导入模块时，Python 会搜索指定的路径。可以使用 sys.path 查看搜索路径：

import sys
print(sys.path)

可以在 sys.path 中添加自定义路径：

import sys
sys.path.append('/path/to/your/modules')

2.包

包 是一个包含多个模块的目录，通过在目录中包含一个 __init__.py 文件（可以是空文件）来表示这个目录是一个包。包可以包含子包和模块。

创建包

创建一个包 mypackage，其目录结构如下：

mypackage/
    __init__.py
    module1.py
    module2.py

module1.py 内容：

# module1.py

def foo():
    return "foo from module1"

module2.py 内容：

# module2.py

def bar():
    return "bar from module2"

导入包中的模块

可以使用 import 导入包中的模块：

import mypackage.module1
import mypackage.module2

print(mypackage.module1.foo())
print(mypackage.module2.bar())

使用 from ... import ... 导入

可以使用 from ... import ... 导入包中的特定模块或函数：

from mypackage.module1 import foo
from mypackage.module2 import bar

print(foo())
print(bar())

3.相对导入

在包内部，可以使用相对导入来导入同一包中的模块。假设在 mypackage 包中有一个子包 subpkg 和一个模块 module3.py：

mypackage/
    __init__.py
    module1.py
    subpkg/
        __init__.py
        module3.py

module3.py 可以使用相对导入：

# module3.py

from ..module1 import foo

def baz():
    return f"baz and {foo()}"

4.示例代码

以下是一个综合示例，展示了如何创建和使用模块和包：

目录结构：

myproject/
    main.py
    mypackage/
        __init__.py
        module1.py
        module2.py

module1.py 内容：

# module1.py

def greet(name):
    return f"Hello, {name}!"

module2.py 内容：

# module2.py

def farewell(name):
    return f"Goodbye, {name}!"

main.py 内容：

# main.py

from mypackage import module1, module2

print(module1.greet("Alice"))
print(module2.farewell("Bob"))

运行 main.py 将输出：

Hello, Alice!
Goodbye, Bob!

通过模块和包，Python 提供了一个强大的组织代码的方式，使代码更加模块化和可维护。