python语法

基础语法

语句分割符 ：用换行符为语句分隔符一行一个语句 也可一行多语句用分号隔开但不推荐

关于缩进： 不得随意缩进 代码顶格写

注释 ：单行用 # 来表示注释，多行则用3对单引号或者双引号来表示

标识符： 字母，数字，下划线 ，数字不开头区分大小写

关键字： 可以使用help命令来查看关键字的用法

print(help("keyword"))

关键字的查看：

import keyword 
print(keword.kwlist)

数据类型：

• 整数（int）：用于存储整数值，例如1、-5、100等。整数可以是正数、负数或零。

• 浮点数（float）：用于存储带有小数点的数值，例如3.14、-0.5、2.0等。

• 字符串（str）：用于存储文本数据，例如”Hello, World!”、’Python’等。字符串可以用单引号或双引号括起来。

• 列表（list）：用于存储一组有序的数据项，可以包含不同数据类型的元素。列表使用方括号 [] 定义，例如[1, 2, 3, ‘apple’]。

• 元组（tuple）：类似于列表，但是元组的元素是不可变的，使用圆括号 () 定义，例如(1, 2, 3, ‘banana’)。

• 字典（dictionary）：用于存储键-值对，每个键都映射到一个值。字典使用花括号 {} 定义，例如{‘name’: ‘Alice’, ‘age’: 30}。

• 集合（set）：用于存储不重复的元素，集合中的元素是无序的。集合使用花括号 {} 或set()函数定义，例如{1, 2, 3}。

• 布尔值（bool）：用于表示真值（True）或假值（False

• None：表示一个特殊的空值或缺失值。

除了这些基本数据类型，Python还支持更复杂的数据类型，例如自定义类、模块和文件对象等。Python还具有动态类型系统，这意味着变量的数据类型是在运行时根据其值自动确定的，不需要显式指定类型。

数据类型的查看:

print(type(dict_demo))

字典类型：

字典（Dictionary）是Python中的一种数据类型，用于存储键-值对。每个键映射到一个特定的值，这使得字典非常适合用于表示映射关系或关联数据。字典是无序的，因此不像列表或元组那样按照索引顺序存储数据。

1. 创建字典：可以使用花括号 {} 来创建一个字典，或者使用dict()构造函数。例如：

   my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

2. 访问字典元素：可以通过键来访问字典中的值。例如：

   print(my_dict['name'])  # 输出：'Alice'

   如果访问不存在的键，会引发KeyError异常，为了避免这种情况，可以使用get()方法：

   print(my_dict.get('gender', 'Not specified'))  # 输出：'Not specified'

3. 修改字典元素：可以通过键来修改字典中的值。例如：

   my_dict['age'] = 31  # 修改年龄为31

4. 添加新键值对：可以通过指定新的键来添加新的键值对。例如：

   my_dict['job'] = 'Engineer'  # 添加一个新的键值对

5. 删除键值对：使用del语句来删除字典中的键值对。例如：

   del my_dict['city']  # 删除'city'键值对

6. 遍历字典：可以使用循环来遍历字典的键、值或键值对。例如：

   for key in my_dict:
       print(key, my_dict[key])
   
   for value in my_dict.values():
       print(value)
   
   for key, value in my_dict.items():
       print(key, value)

7. 字典的长度：使用len()函数可以获得字典中键值对的数量。

   print(len(my_dict))  # 输出：3

8. 检查键是否存在：可以使用in关键字来检查字典中是否存在某个键。

   if 'age' in my_dict:
       print('Age is in the dictionary.')

列表（List）类型：

1. 有序性：列表是有序的数据结构，这意味着元素按照它们添加的顺序存储，并可以通过索引来访问。索引从0开始。

2. 可重复性：列表允许包含重复的元素，你可以多次添加相同的值。

3. 可变性：列表是可变的，你可以添加、删除或修改列表中的元素。

4. 定义：列表使用方括号 [] 定义，元素之间用逗号 , 分隔。例如：

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

Python中列表（list）是一种有序的集合，可以随时添加和删除其中的元素。以下是一些常见的列表操作：

创建列表：使用方括号（[]）来创建一个空列表，并可以通过逐个添加元素来初始化它。例如：

python

my_list = [1, 2, 3, 4, 5]  # 创建一个包含整数的列表

添加元素：使用 append() 方法在列表的末尾添加一个元素，使用 extend() 方法添加另一个列表中的所有元素。例如：

my_list.append(6)  # 在列表末尾添加一个元素
my_list.extend([7, 8])  # 添加另一个列表中的所有元素

删除元素：使用 remove() 方法删除列表中的一个特定元素，使用 clear() 方法清空整个列表。例如：

my_list.remove(3)  # 删除一个特定元素
my_list.clear()  # 清空整个列表

修改元素：使用索引来修改列表中的特定元素。例如：

my_list[0] = 10  # 修改第一个元素

排序列表：使用 sort() 方法对列表进行排序，使用 sorted() 函数返回一个新的已排序列表。例如：

my_list.sort()  # 对列表进行排序
sorted_list = sorted([2, 5, 1, 9, 3])  # 返回一个新的已排序列表

切片操作：使用切片语法来获取列表的一部分，或修改列表的一部分。例如：

new_list = my_list[1:4]  # 获取列表的一部分
my_list[1:3] = [20, 21]  # 修改列表的一部分

集合（Set）类型：

1. 无序性：集合是无序的，这意味着元素的存储顺序不确定，你不能通过索引来访问集合中的元素。

2. 唯一性：集合中的元素是唯一的，不允许重复的元素。如果尝试添加相同的元素，集合将自动去重。

3. 可变性：集合是可变的，你可以添加和删除元素，但集合中的元素本身不能修改。

4. 定义：集合使用花括号 {} 或set()构造函数定义，元素之间用逗号 , 分隔。例如：

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

集合通常用于需要存储一组唯一元素的情况，而列表用于需要按顺序存储并允许重复元素的情况。集合在执行集合操作（如并集、交集、差集等）时也非常有用。列表和集合都有其适用的场景，根据你的需求来选择使用哪种数据类型。

元组类型：

元组（Tuple）是Python中的一个有序不可变数据类型，它允许你存储多个值，并且这些值在创建后不可更改。与列表不同，元组使用圆括号 () 定义，而不是方括号 []。

1. 元组（Tuple）是Python中的一种数据结构，它是不可变的、有序的序列。这意味着一旦创建了元组，就无法修改它的内容。以下是元组的一些基本操作：

   创建元组：

   my_tuple = (1, 2, 3)

   访问元素：

   print(my_tuple[0])  # 输出 1

   切片操作：

   slice_of_tuple = my_tuple[1:3]  # 返回 (2, 3)

   合并元组：

   tuple1 = (1, 2, 3)
   tuple2 = (4, 5, 6)
   merged_tuple = tuple1 + tuple2  # 返回 (1, 2, 3, 4, 5, 6)

   重复元素：

   repeated_tuple = my_tuple * 2  # 返回 (1, 2, 3, 1, 2, 3)

   获取元组长度：

   length = len(my_tuple)  # 返回 3

   检查元素是否存在：

   is_present = 2 in my_tuple  # 返回 True

   元组解包：

   a, b, c = my_tuple
   # 现在a为1，b为2，c为3

   元组内建函数：

   count = my_tuple.count(2)  # 返回 1，统计元素2的个数
   index = my_tuple.index(3)  # 返回 2，返回元素3的索引位置

   不可变性：

   由于元组是不可变的，你不能对元素进行修改、添加或删除。这使得元组适用于一些特定的场景，如用作字典的键，或者在程序中需要保持数据不可变性的地方。

   总体而言，元组是一个轻量级的数据结构，适用于存储一些相关的数据，而且由于其不可变性，具有一些额外的性能优势。

元组的使用场景：元组通常用于需要不可变性的情况，比如表示某个对象的多个属性或坐标。它们还可以用作字典的键，而列表不能用作字典的键，因为字典的键必须是可哈希的，而元组是可哈希的。

元组在Python中具有多种用途，尤其在需要确保数据不可变性的情况下非常有用。如果你需要一个有序的、可变的数据结构，可以使用列表。

关于哈希：

• 哈希函数（Hash Function）是一种数学函数，它将输入数据（或”消息”）转换为固定长度的字符串，通常是固定长度的二进制序列或十六进制数字。哈希函数的输出通常称为哈希值或散列值。哈希函数的主要目的是将输入数据映射到一个紧凑的、固定大小的输出，以便在数据结构（如哈希表）中快速查找和比较数据。

哈希函数的特点包括：

1. 固定输出长度：哈希函数的输出长度是固定的，无论输入数据的大小。这使得哈希值具有相同的大小，无论输入数据是多大还是多小。
2. 确定性：对于相同的输入数据，哈希函数总是产生相同的哈希值。这是非常重要的，因为它允许在不同时间或不同地点对相同数据进行哈希，并获得相同的结果。
3. 高效性：哈希函数应该在短时间内计算出哈希值，使得快速查找和比较成为可能。
4. 离散性：哈希函数的输出应该看起来随机，即使输入数据只有微小的差异，哈希值也应该差异很大，以减少碰撞的可能性。碰撞是指两个不同的输入数据映射到相同的哈希值。

哈希函数在计算机科学和信息安全领域有广泛的应用，包括：

• 数据结构：用于实现哈希表，用于快速查找和插入数据。
• 安全：用于密码学和数字签名，确保数据完整性和安全性。
• 数据校验：用于验证数据的完整性，如校验和和散列值。
• 数据压缩：用于压缩数据，例如压缩算法中的散列函数。
• 数据分片：用于分布式系统中的数据分片和负载均衡。

常见的哈希函数包括MD5、SHA-1、SHA-256等，它们在不同的应用中具有不同的性能和安全性特点。在安全领域，由于计算能力的增加，一些较旧的哈希函数已经不再安全，因此更强大的哈希函数被广泛采用。

• 哈希性：
  在Python中，”可哈希”（hashable）是一个对象的属性，它意味着这个对象可以被用作字典的键或存储在集合（例如集合和frozenset）中。可哈希的对象具有以下特点：

1. 不可变性：可哈希的对象必须是不可变的，即在创建后不能改变其状态。这确保了对象的哈希值在其生命周期内保持不变。
2. 具有哈希值（唯一性）：可哈希的对象必须具有一个哈希值（hash value），这是一个整数，代表对象的特定标识。哈希值是通过一种哈希函数计算得出的，这个函数根据对象的内容计算一个唯一的整数，用于快速查找和比较对象。

数字类型：

Python提供了多种数字类型，用于表示不同种类的数字数据。以下是一些常见的Python数字类型：

1. 整数（int）：整数是最常见的数字类型，用于表示整数值。例如：-5、0、42等。

2. 浮点数（float）：浮点数用于表示带有小数点的数值，包括整数和分数。例如：3.14、-0.5、2.0等。

3. 复数（complex）：复数用于表示复数数值，其中包含实部和虚部。复数以j或J结尾。例如：3 + 4j、-2.5 - 1.2j等。

4. 布尔值（bool）：布尔值用于表示真值（True）或假值（False）。它们通常用于控制流程和条件判断。例如：True、False。

5. 十进制数（decimal）：十进制数是一种高精度的浮点数类型，用于精确的十进制运算。它通常用于需要避免二进制浮点数精度问题的场景。

6. 分数（fractions）：分数用于表示有理数，它包括分子和分母。Python的fractions模块可以处理分数运算。

7. 固定精度数（fixed-point numbers）：可以使用decimal.Decimal类创建固定精度的数值，用于精确的小数运算。

8. 数值常量：Python还提供了一些特殊的数值常量，如float('inf')（正无穷大）、float('-inf')（负无穷大）和float('nan')（NaN，表示非数值）。

# 整数
my_integer = 42

# 浮点数
my_float = 3.14

# 复数
my_complex = 2 + 3j

# 布尔值
my_bool = True

# 十进制数
from decimal import Decimal
my_decimal = Decimal('0.1')

# 分数
from fractions import Fraction
my_fraction = Fraction(3, 4)

# 固定精度数
from decimal import Decimal
my_fixed_point = Decimal('0.1')

# 数值常量
positive_infinity = float('inf')
negative_infinity = float('-inf')
not_a_number = float('nan')

# 数学操作
result = my_integer + my_float
print("Integer + Float =", result)

result = my_complex * (2 + 1j)
print("Complex * Complex =", result)

result = my_bool and False
print("Boolean AND operation:", result)

result = my_decimal + Decimal('0.2')
print("Decimal + Decimal =", result)

result = my_fraction * Fraction(2, 3)
print("Fraction * Fraction =", result)

result = my_fixed_point + Decimal('0.2')
print("Fixed Point + Decimal =", result)

# 数值常量
print("Positive Infinity:", positive_infinity)
print("Negative Infinity:", negative_infinity)
print("Not a Number (NaN):", not_a_number)

在Python中，你可以进行不同数据类型之间的转换，以满足不同的计算和操作需求。以下是一些常见的数据类型转换示例：

1. 整数与浮点数之间的转换：

   int_number = 5
   float_number = float(int_number)  # 将整数转换为浮点数
   print(float_number)
   
   float_number = 3.14
   int_number = int(float_number)  # 将浮点数转换为整数（截断小数部分）
   print(int_number)

2. 字符串与整数/浮点数之间的转换：

   number = 42
   number_as_str = str(number)  # 将整数转换为字符串
   print(number_as_str)
   
   string_number = "3.14"
   float_number = float(string_number)  # 将字符串转换为浮点数
   print(float_number)

3. 字符串与列表/元组之间的转换：

   # 字符串到列表
   my_string = "Hello, World!"
   my_list = list(my_string)
   print(my_list)
   
   # 列表到字符串
   my_list = ['H', 'e', 'l', 'l', 'o']
   my_string = ''.join(my_list)
   print(my_string)
   
   # 字符串到元组
   my_string = "apple, banana, cherry"
   my_tuple = tuple(my_string.split(', '))
   print(my_tuple)

4. 字符串与字典之间的转换（一种常见的数据格式是JSON）：

   import json
   
   # 字符串到字典
   my_string = '{"name": "Alice", "age": 30}'
   my_dict = json.loads(my_string)
   print(my_dict)
   
   # 字典到字符串
   my_dict = {"name": "Bob", "age": 25}
   my_string = json.dumps(my_dict)
   print(my_string)

5. 字符串到布尔值的转换：

   true_string = "True"
   false_string = "False"
   true_bool = bool(true_string)
   false_bool = bool(false_string)
   print(true_bool, false_bool)

6. 整数到字符的转换（通常用于ASCII码值的转换）：

   char_code = 65
   char = chr(char_code)  # 将整数转换为对应的字符
   print(char)

这些示例展示了不同数据类型之间的一些基本转换方法，但要注意，不是所有的类型转换都是可行的。在执行转换之前，应该确保数据是可以安全转换的，以避免潜在的错误。如果数据类型不兼容，可能会引发异常。因此，在转换数据类型时要小心谨慎。

输入与输出：

Python中的输入与输出通常是指如何从用户获取输入并向用户显示输出。这是在编程中非常重要的概念，因为它允许你与程序进行交互。以下是Python中的输入和输出的一些基本方式和示例：

输出（输出到屏幕或文件）：

在Python中，你可以使用内置的print()函数来输出文本或其他数据到屏幕上或保存到文件。以下是一些示例：

# 输出到屏幕
print("Hello, World!")

# 输出变量的值
name = "Alice"
age = 30
print("Name:", name, "Age:", age)

# 使用格式化字符串
print(f"My name is {name} and I am {age} years old.")

输入（从用户获取输入）：

你可以使用内置的input()函数来从用户获取文本输入。input()函数会返回用户输入的内容作为字符串。你可以将其转换为其他数据类型，如整数或浮点数，如果需要的话。

# 获取用户输入并保存到变量
user_input = input("Please enter your name: ")
print("You entered:", user_input)

# 获取整数输入
age = int(input("Please enter your age: "))
print("In 10 years, you will be", age + 10)

文件输入与输出：

除了在屏幕上打印和从用户获取输入，你还可以读写文件。Python提供了内置的文件操作函数来处理文件输入和输出。以下是一个示例：

# 写入文件
with open("example.txt", "w") as file:
    file.write("This is an example file.\n")
    file.write("Hello, Python!")

# 读取文件
with open("example.txt", "r") as file:
    contents = file.read()
    print("File contents:")
    print(contents)

在示例中，我们使用open()函数打开文件，指定打开文件的模式（”w”表示写入，”r”表示读取）。使用with语句可以确保文件在操作结束后被正确关闭。

这些是Python中基本的输入和输出方式，你可以根据需要进行更高级的操作，如处理异常、格式化输出、读写不同类型的文件等。输入和输出对于与用户进行交互和处理文件数据非常重要。

运算符：

Python提供了多种运算符，用于执行各种数学和逻辑操作。下面是Python中一些常见的运算符以及它们的运算优先级（从高到低）：

算术运算符：

1. **：指数
2. *、/、//、%：乘法、除法、整数除法、取余
3. +、-：加法、减法

比较运算符：

4. ==、!=：等于、不等于
5. <、>、<=、>=：小于、大于、小于等于、大于等于

逻辑运算符：

6. not：逻辑非
7. and：逻辑与
8. or：逻辑或

位运算符：

9. &、|、^：按位与、按位或、按位异或
10. <<、>>：左移、右移

成员运算符：

11. in：成员关系测试
12. not in：成员关系测试的否定

身份运算符：

13. is：对象标识测试
14. is not：对象标识测试的否定

赋值运算符：

15. =：赋值
16. +=、-=、*=、/=：加法赋值、减法赋值、乘法赋值、除法赋值等

其他运算符：

17. ()：函数调用
18. []：列表、元组、字典索引
19. .：属性访问
20. :：切片

运算符优先级：

运算符的优先级决定了它们在表达式中的计算顺序。以下是一些常见运算符的优先级，从高到低排列：

1. **：指数
2. *、/、//、%：乘法、除法、整数除法、取余
3. +、-：加法、减法
4. <<、>>：左移、右移
5. &：按位与
6. ^：按位异或
7. |：按位或
8. <、>、<=、>=：比较运算符
9. ==、!=：等于、不等于
10. not：逻辑非
11. and：逻辑与
12. or：逻辑或
13. in、not in：成员运算符
14. is、is not：身份运算符
15. =、+=、-=、*=、/=：赋值运算符

你可以使用括号来改变运算的优先级，确保表达式按照你的意图进行计算。例如，使用括号来明确指定某些运算的顺序，如 (2 + 3) * 4。这将确保加法在乘法之前执行。

del关键字

在Python中，del关键字用于删除变量或删除数据对象（如列表、元组、字典等）中的元素。

如果你想删除一个变量，可以这样使用del关键字：

x = 10
del x

上述代码将删除变量x。在删除变量后，再使用该变量会引发一个错误。

另外，如果你想从一个列表中删除一个元素，可以这样使用del关键字：

my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除第三个元素

上述代码将删除列表中的第三个元素。你也可以使用索引范围来删除多个元素：

my_list = [1, 2, 3, 4, 5]
del my_list[1:3]  # 删除第二个和第三个元素

上述代码将删除列表中的第二个和第三个元素。

Del关键字也可以用于删除元组中的元素。然而，元组是不可变的，这意味着我们不能像在列表中那样使用 del 来删除单个元素。

在元组中，del只能删除整个元组或者给元组赋值一个新的值。以下是示例：

#创建一个元组

my_tuple = (1, 2, 3, 4, 5)

# 删除列表中的第三个元素

del my_list[2]

#将修改后的列表转回元组

my_tuple = tuple(my_list)

循环：

for循环：

Python的for循环是一种迭代循环，用于遍历序列（可以是列表、元组、字典、集合或字符串）与其他编程语言中的for关键字不同，它更像是其他面向对象编程语言中的迭代器方法。使用for循环，我们可以执行一组语句，对于列表、元组、集合等中的每个项目，执行一次

fruits = ['apple', 'banana', 'orange']

for fruit in fruits:
    print(fruit)

range()函数：

range() 函数是一个用于生成等差数列的内置函数，常用于 for 循环中。它的基本语法是：

range([start], stop, [step])

• start（可选）：数列的起始值，默认为 0。
• stop：数列的结束值（不包含在数列内）。
• step（可选）：数列中每个元素之间的步长，默认为 1。

for i in range(5):
    print(i)
# 生成从 0 到 4 的整数序列

#output：
0
1
2
3
4

for i in range(1, 10, 2):
    print(i)
#指定起始值、结束值和步长：

#output
1
3
5
7
9

使用 range() 创建一个列表：

pythonCopy codemy_list = list(range(3, 10, 2))
print(my_list)

输出：

csharpCopy code
[3, 5, 7, 9]

注意：在 Python 2 中，range() 函数返回的是一个列表。在 Python 3 中，range() 返回一个 range 对象，需要通过 list() 函数转换为列表。

while循环：

while 循环是另一种在 Python 中用于控制流程的迭代结构。与 for 循环不同，while 循环不是基于序列的迭代，而是基于一个条件的真假来决定循环是否继续执行。

while 循环的基本语法如下：

pythonCopy codewhile 条件:
    # 循环体代码

在每次循环迭代时，都会检查 条件 是否为真。只要条件为真，循环体内的代码就会被执行。当条件变为假时，循环终止，程序将继续执行循环之后的代码。

例如，以下是一个简单的 while 循环示例，计算并打印从 1 到 5 的平方：

i = 0
while i <= 5:
    print(i)
    
    i += 1

这段代码是一个简单的 while 循环，目的是打印从 0 到 5 的整数：

1. 初始时，i 的值为 0。
2. 进入 while 循环，检查条件 i <= 5 是否为真，因为 i 的初始值是 0，条件为真。
3. 打印当前的 i 的值（0）。
4. i += 1 将 i 的值增加 1，现在 i 的值为 1。
5. 回到循环的开始，再次检查条件 i <= 5。由于 i 的值现在是 1，条件仍为真。
6. 打印当前的 i 的值（1）。
7. i += 1 再次将 i 的值增加 1，现在 i 的值为 2。
8. 重复上述步骤，直到 i 的值达到 6。
9. 当 i 的值为 6 时，条件 i <= 5 不再为真，循环终止。

因此，这段代码将打印出从 0 到 5 的整数：

#output
1
2
3
4
5

需要小心使用 while 循环，确保在循环体内的代码中有适当的条件使循环能够结束，否则可能导致死循环。

for 循环用于迭代可迭代对象，而 while 循环基于条件的真假来执行，直到条件不再满足。

break 与 continue 关键字：

continue 和 break 是两个在编程语言中常用的控制流关键字，它们通常用于控制循环的执行。

1. continue：

   • continue 语句用于跳过当前循环中剩余的代码，直接进入下一次循环迭代。
   • 当程序执行到 continue 时，它会立即停止当前迭代并跳到下一次迭代的开始。
   • 在循环体中，continue 之后的代码不会被执行，而是直接进入下一次循环。

   示例：

   for i in range(5):
       if i == 2:
           continue
       print(i)

   输出：

   0
   1
   3
   4

   在这个例子中，当 i 等于 2 时，continue 被触发，所以在该次循环中 print(i) 不会执行，直接进入下一次循环。

2. break：

   • break 语句用于立即终止循环，跳出循环体，不再执行循环内尚未执行的代码。
   • 当程序执行到 break 时，它会跳出包含它的最内层的循环，然后继续执行循环外的代码。

   示例（使用 Python 语言）：

   for i in range(5):
       if i == 2:
           break
       print(i)

   输出：

   0
   1

   在这个例子中，当 i 等于 2 时，break 被触发，整个循环立即终止，不再执行后续的循环体内代码。

总的来说，continue 用于跳过当前迭代，而 break 用于完全终止循环。这两者都是在特定条件下修改循环行为的有用工具。

当提到Python函数时，通常指的是一段可重复使用的代码块，用于执行特定的任务。函数允许您将代码模块化，提高代码的可读性和可维护性。以下是Python函数的基本语法和一些重要的概念：

函数:

def function_name(parameters):
    # 函数体
    # 可以包含一系列语句，用于执行特定任务
    return result  # 可选，用于返回结果

函数的调用

result = function_name(arguments)

示例

# 定义一个简单的函数
def greet(name):
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # 输出: Hello, Alice!

参数

• 必选参数： 函数按照参数的位置来匹配值。

  def add(x, y):
      return x + y
  
  result = add(3, 5)

• 关键字参数（Keyword Arguments）： 明确指定参数的名称。

  def greet(name, greeting='Hello'):
      return f"{greeting}, {name}!"
  
  message = greet(name="Bob", greeting="Hi")

• 默认参数（Default Arguments）： 给参数设置默认值。可以在下面更改

  def power(base, exponent=2):
      return base ** exponent
  
  result = power(3)  # 默认使用 exponent=2

• 可选参数： 可以选择传入或不传入参数：

  def add(*args):
      return sum(args)
  
  result = add(1, 2, 3, 4)

• kwargs（任意数量的关键字参数）： 允许函数接受任意数量的关键字参数。

  def print_info(**kwargs):
      for key, value in kwargs.items():
          print(f"{key}: {value}")
  
  print_info(name="John", age=30)

返回值

• 函数可以使用 return 语句返回一个值。
• 如果没有使用 return，函数默认返回 None。

作用域

• 函数内外有不同的作用域，局部变量和全局变量的概念。

Lambda函数

• 匿名函数，通过 lambda 关键字定义。

  square = lambda x: x**2
  result = square(5)

这些是Python函数的一些基本概念，有助于将代码划分为可管理的部分，提高代码的重用性。

类和对象：

当我们讨论Python中的类和对象时，我们实际上是在谈论面向对象编程（Object-Oriented Programming，OOP）。在Python中，一切都是对象，包括整数、字符串、函数等。类是一种用于创建对象的蓝图，而对象是类的实例。

让我们深入了解一下Python中的类和对象。

类（Class）:

1. 定义类： 在Python中，通过使用class关键字来定义类。

   class MyClass:
       # 类的属性和方法
       pass

2. 构造函数（__init__）： 构造函数是在创建类的实例时调用的特殊方法，用于初始化对象的属性。

   class MyClass:
       def __init__(self, param1, param2):
           self.param1 = param1
           self.param2 = param2

3. 属性和方法： 类包含属性（变量）和方法（函数）。属性用于存储数据，方法用于执行操作。

   class MyClass:
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
       def display_info(self):
           print(f"Name: {self.name}, Age: {self.age}")

对象（Object）:

1. 创建对象： 对象是类的实例。通过调用类的构造函数，可以创建类的对象。

   obj = MyClass("John", 25)

2. 访问属性和调用方法： 使用点运算符可以访问对象的属性和调用对象的方法。

   print(obj.name)  # 访问属性
   obj.display_info()  # 调用方法

继承（Inheritance）:

1. 定义子类： 子类可以继承父类的属性和方法。

   class MyChildClass(MyClass):
       def __init__(self, name, age, hobby):
           super().__init__(name, age)
           self.hobby = hobby

2. 调用父类方法： 使用super()函数可以调用父类的方法。

   def display_info(self):
       super().display_info()
       print(f"Hobby: {self.hobby}")

封装（Encapsulation）:

1. 私有成员： 在Python中，通过在属性或方法名前加上双下划线__来定义私有成员。

   class MyClass:
       def __init__(self, name):
           self.__name = name
   
       def get_name(self):
           return self.__name

多态（Polymorphism）:

1. 方法重写： 子类可以重写父类的方法，实现多态。

   class MyChildClass(MyClass):
       def display_info(self):
           print(f"Overridden Display Info: {self.name}")

以上是关于Python中类和对象的基本介绍。类和对象是面向对象编程的核心概念，它们提供了一种组织和结构化代码的方式，使得代码更加模块化和可维护。

正则表达式（Regular Expression，简称Regex或RegExp）是一种用于匹配字符串模式的强大工具。在Python中，可以使用re模块来操作正则表达式。

正则表达式：

1. 导入 re 模块

import re

2. 匹配字符串

使用 re.match(pattern, string) 来匹配字符串的起始部分。

pattern = r"Hello"
string = "Hello, World!"
match = re.match(pattern, string)

if match:
    print("Match found:", match.group())
else:
    print("Match not found")

3. 搜索字符串

使用 re.search(pattern, string) 在整个字符串中搜索匹配项。

pattern = r"World"
string = "Hello, World!"
search_result = re.search(pattern, string)

if search_result:
    print("Match found:", search_result.group())
else:
    print("Match not found")

4. 查找所有匹配项

使用 re.findall(pattern, string) 来找到字符串中所有匹配项。

pattern = r"\d+"  # 匹配数字
string = "There are 42 apples and 9 oranges."
matches = re.findall(pattern, string)

print("Matches:", matches)

5. 替换字符串中的匹配项

使用 re.sub(pattern, replacement, string) 来替换字符串中的匹配项。

pattern = r"\s"  # 匹配空白字符
replacement = "-"
string = "This is a sample string."
modified_string = re.sub(pattern, replacement, string)

print("Original string:", string)
print("Modified string:", modified_string)

6. 切分字符串

使用 re.split(pattern, string) 来根据模式将字符串切分成列表。

pattern = r"\s"  # 匹配空白字符
string = "This is a sample string."
split_result = re.split(pattern, string)

print("Original string:", string)
print("Split result:", split_result)

当然，下面是一个简单的正则表达式例子，假设我们想从一个字符串中提取所有的电子邮件地址：

import re

# 字符串包含一些电子邮件地址
text = "Contact us at support@example.com or sales@example.org. For more information, email info@example.com."

# 定义匹配电子邮件地址的正则表达式模式
pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

# 使用 re.findall() 查找所有匹配项
matches = re.findall(pattern, text)

# 打印匹配的电子邮件地址
for match in matches:
    print(match)

在这个例子中，正则表达式模式 r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b' 用于匹配标准的电子邮件地址格式。解释一下这个模式：

• \b: 单词边界，确保我们匹配整个电子邮件地址而不是部分单词。
• [A-Za-z0-9._%+-]+: 匹配电子邮件地址中的用户名部分，可以包含字母、数字、下划线、百分号、加号和减号。
• @: 匹配电子邮件地址中的 “@” 符号。
• [A-Za-z0-9.-]+: 匹配电子邮件地址中的域名部分，可以包含字母、数字、点和减号。
• \.: 匹配电子邮件地址中的点号。
• [A-Z|a-z]{2,}: 匹配电子邮件地址中的顶级域名，至少包含两个字母。
• \b: 单词边界，与模式的开始相匹配。

运行上述代码，将输出从文本中提取的所有电子邮件地址。请注意，这只是一个简单的例子，实际的电子邮件地址验证可能需要更复杂的正则表达式。

文件

在Python中，文件操作是处理文件的重要任务之一。以下是一些基本的文件操作：

打开文件

使用 open() 函数来打开一个文件。语法如下：

file = open("filename.txt", mode)

其中：

• “filename.txt” 是文件名。
• mode 是打开文件的模式，如 ‘r’（只读），’w’（写入），’a’（追加），’r+’（读写），等等。

读取文件内容

使用 read() 方法来读取文件的全部内容，或者使用 readline() 或 readlines() 方法逐行读取内容。

content = file.read()  # 读取整个文件内容
line = file.readline()  # 读取一行内容
lines = file.readlines()  # 读取所有行，返回一个列表

写入文件

使用 write() 方法来写入内容到文件中。

file.write("This is a line of text.")

追加文件

使用追加模式 'a' 来打开文件，然后使用 write() 方法追加内容。

file = open("filename.txt", 'a')
file.write("This is additional text.")
file.close()

关闭文件

使用 close() 方法来关闭文件，释放文件资源。

file.close()

使用 with 语句

使用 with 语句来自动管理文件的上下文，确保在使用完文件后正确地关闭它。

with open("filename.txt", 'r') as file:
    content = file.read()
    # 文件在这个代码块结束后自动关闭

这只是文件操作的基本示例。还有其他更高级的文件操作，如文件的复制、移动、删除，以及处理文件和目录的路径等。记得在文件操作中谨慎处理异常，确保程序稳定性。