基础语法

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

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

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

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

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

1	print(help("keyword"))

关键字的查看：

1 2	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还具有动态类型系统，这意味着变量的数据类型是在运行时根据其值自动确定的，不需要显式指定类型。

数据类型的查看:

1	print(type(dict_demo))

字典类型：

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

创建字典：可以使用花括号 {} 来创建一个字典，或者使用dict()构造函数。例如：
1
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
访问字典元素：可以通过键来访问字典中的值。例如：
1
print(my_dict['name']) # 输出：'Alice'
如果访问不存在的键，会引发KeyError异常，为了避免这种情况，可以使用get()方法：
1
print(my_dict.get('gender', 'Not specified')) # 输出：'Not specified'
修改字典元素：可以通过键来修改字典中的值。例如：
1
my_dict['age'] = 31 # 修改年龄为31
添加新键值对：可以通过指定新的键来添加新的键值对。例如：
1
my_dict['job'] = 'Engineer' # 添加一个新的键值对
删除键值对：使用del语句来删除字典中的键值对。例如：
1
del my_dict['city'] # 删除'city'键值对

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

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)

字典的长度：使用len()函数可以获得字典中键值对的数量。
1
print(len(my_dict)) # 输出：3
检查键是否存在：可以使用in关键字来检查字典中是否存在某个键。
1
2
if 'age' in my_dict:
print('Age is in the dictionary.')

列表（List）类型：

有序性：列表是有序的数据结构，这意味着元素按照它们添加的顺序存储，并可以通过索引来访问。索引从0开始。
可重复性：列表允许包含重复的元素，你可以多次添加相同的值。
可变性：列表是可变的，你可以添加、删除或修改列表中的元素。
定义：列表使用方括号 [] 定义，元素之间用逗号 , 分隔。例如：
1
my_list = [1, 2, 3, 4, 5]

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

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

1
2
3

python

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

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

1
2
3


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

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

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

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

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

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

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

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



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

集合（Set）类型：

无序性：集合是无序的，这意味着元素的存储顺序不确定，你不能通过索引来访问集合中的元素。
唯一性：集合中的元素是唯一的，不允许重复的元素。如果尝试添加相同的元素，集合将自动去重。
可变性：集合是可变的，你可以添加和删除元素，但集合中的元素本身不能修改。
定义：集合使用花括号 {} 或set()构造函数定义，元素之间用逗号 , 分隔。例如：
1
my_set = {1, 2, 3, 4, 5}

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

元组类型：

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

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

创建元组：
1
my_tuple = (1, 2, 3)
访问元素：
1
print(my_tuple[0]) # 输出 1
切片操作：
1
slice_of_tuple = my_tuple[1:3] # 返回 (2, 3)
合并元组：
1
2
3
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
merged_tuple = tuple1 + tuple2 # 返回 (1, 2, 3, 4, 5, 6)
重复元素：
1
repeated_tuple = my_tuple * 2 # 返回 (1, 2, 3, 1, 2, 3)
获取元组长度：
1
length = len(my_tuple) # 返回 3
检查元素是否存在：
1
is_present = 2 in my_tuple # 返回 True
元组解包：
1
2
a, b, c = my_tuple
# 现在a为1，b为2，c为3
元组内建函数：
1
2
count = my_tuple.count(2) # 返回 1，统计元素2的个数
index = my_tuple.index(3) # 返回 2，返回元素3的索引位置
不可变性：

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

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

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

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

关于哈希：

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

哈希函数的特点包括：

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

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

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

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

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

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

数字类型：

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

整数（int）：整数是最常见的数字类型，用于表示整数值。例如：-5、0、42等。
浮点数（float）：浮点数用于表示带有小数点的数值，包括整数和分数。例如：3.14、-0.5、2.0等。
复数（complex）：复数用于表示复数数值，其中包含实部和虚部。复数以j或J结尾。例如：3 + 4j、-2.5 - 1.2j等。
布尔值（bool）：布尔值用于表示真值（True）或假值（False）。它们通常用于控制流程和条件判断。例如：True、False。
十进制数（decimal）：十进制数是一种高精度的浮点数类型，用于精确的十进制运算。它通常用于需要避免二进制浮点数精度问题的场景。
分数（fractions）：分数用于表示有理数，它包括分子和分母。Python的fractions模块可以处理分数运算。
固定精度数（fixed-point numbers）：可以使用decimal.Decimal类创建固定精度的数值，用于精确的小数运算。
数值常量：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中，你可以进行不同数据类型之间的转换，以满足不同的计算和操作需求。以下是一些常见的数据类型转换示例：

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

int_number = 5
float_number = float(int_number)  # 将整数转换为浮点数
print(float_number)

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

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

number = 42
number_as_str = str(number)  # 将整数转换为字符串
print(number_as_str)

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

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

# 字符串到列表
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)

字符串与字典之间的转换（一种常见的数据格式是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)

字符串到布尔值的转换：

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

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

1
2
3

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中一些常见的运算符以及它们的运算优先级（从高到低）：

算术运算符：

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

比较运算符：

==、!=：等于、不等于
<、>、<=、>=：小于、大于、小于等于、大于等于

逻辑运算符：

not：逻辑非
and：逻辑与
or：逻辑或

位运算符：

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

成员运算符：

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

身份运算符：

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

赋值运算符：

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

其他运算符：

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

运算符优先级：

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

**：指数
*、/、//、%：乘法、除法、整数除法、取余
+、-：加法、减法
<<、>>：左移、右移
&：按位与
^：按位异或
|：按位或
<、>、<=、>=：比较运算符
==、!=：等于、不等于
not：逻辑非
and：逻辑与
or：逻辑或
in、not in：成员运算符
is、is not：身份运算符
=、+=、-=、*=、/=：赋值运算符

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

del关键字

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

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

1 2	x = 10 del x

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

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

1
2
3


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

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

1 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 循环中。它的基本语法是：

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

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

1
2
3

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

#output：
0
1
2
3
4

1
2
3

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

#output
1
3
5
7
9

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

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

输出：

1 2	csharpCopy code [3, 5, 7, 9]

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

while循环：

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

while 循环的基本语法如下：

1 2	pythonCopy codewhile 条件: # 循环体代码

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

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

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

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

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

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

#output
1
2
3
4
5

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

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

break 与 continue 关键字：

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

continue：
- continue 语句用于跳过当前循环中剩余的代码，直接进入下一次循环迭代。
- 当程序执行到 continue 时，它会立即停止当前迭代并跳到下一次迭代的开始。
- 在循环体中，continue 之后的代码不会被执行，而是直接进入下一次循环。
示例：
1
2
3
4
for i in range(5):
if i == 2:
continue
print(i)
输出：
1
2
3
4
0
1
3
4
在这个例子中，当 i 等于 2 时，continue 被触发，所以在该次循环中 print(i) 不会执行，直接进入下一次循环。
break：
- break 语句用于立即终止循环，跳出循环体，不再执行循环内尚未执行的代码。
- 当程序执行到 break 时，它会跳出包含它的最内层的循环，然后继续执行循环外的代码。
示例（使用 Python 语言）：
1
2
3
4
for i in range(5):
if i == 2:
break
print(i)
输出：
1
2
0
1
在这个例子中，当 i 等于 2 时，break 被触发，整个循环立即终止，不再执行后续的循环体内代码。

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

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

函数:

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

函数的调用

1	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 关键字定义。

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

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

类和对象：

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

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

类（Class）:

定义类： 在Python中，通过使用class关键字来定义类。
1
2
3
class MyClass:
# 类的属性和方法
pass

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

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

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

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)
访问属性和调用方法： 使用点运算符可以访问对象的属性和调用对象的方法。
1
2
print(obj.name) # 访问属性
obj.display_info() # 调用方法

继承（Inheritance）:

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

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

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

1
2
3

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

封装（Encapsulation）:

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

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

    def get_name(self):
        return self.__name

多态（Polymorphism）:

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

1
2
3

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() 函数来打开一个文件。语法如下：

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

其中：

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

读取文件内容

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

1
2
3

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

写入文件

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

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

追加文件

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

1
2
3

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

关闭文件

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

1	file.close()

使用 with 语句

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

1
2
3

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

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