代码收藏家 python相关函数介绍（个人总结版）
目录
with open()语句
读取文件
写入文件
追加到文件
re.sub()语句
简单替换
使用函数进行替换
限制替换次数
使用标志位
splitlines()语句
strip()语句
print()
range()
.format()方法
字典(一种无序的数据结构)
列表(一种有序的数据结构)
元组
容器对比：略
切片
Zfill()函数
upper()函数
startswith()函数
read()函数
readline()函数
readlines()函数
index()函数
split()函数
enumerate()函数
copy()和deepcopy()函数区别
map()函数
os.walk()
PyQt5
QWidget和QMainWindow的区别
类
self 不可以省略的原因
get()
append()
爬虫
JSON 相关函数
1. json.loads()
2. json.load()
3. json.dumps()
4. json.dump()
try – except 用法解释
基本语法
执行逻辑
捕获多种异常
捕获所有异常
else 子句
finally 子句
sorted()
1. 对简单列表排序
2. 按降序排序
3. 对字符串列表按字母顺序排序
4. 对字典列表按字典某个键的值排序
5. 对二维列表按指定列排序
lambda函数
1. 简单的数值计算
2. 字符串操作
3. 列表排序
4. 条件判断
5. 多个参数
f-string（格式化字符串字面值）
基本用法
格式化数值
整数格式化
浮点数格式化
格式化日期和时间
表达式嵌套
转义大括号
进制转换
十进制转其他进制
1. 十进制转二进制
2. 十进制转八进制
3. 十进制转十六进制
其他进制转十进制
1. 二进制转十进制
2. 八进制转十进制
3. 十六进制转十进制
自定义进制转换def int_to_anybase(value, base): if value == 0: return 0 data = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" result = '' while value != 0: result = data[value % base] + result value //= base return resultdef main(): value = int(input("请输入一个整数（代表值）：")) base = int(input("请输入一个整数（代表进制）：")) print(f"10进制{value}转换成{base}进制后的值是{int_to_anybase(value, base)}")if __name__ == '__main__': main()
格式化输出特定进制
1. 使用 f-string
2. 使用 str.format() 方法
/=和//=的区别
运算规则
结果的数据类型
with open()语句
with open()语句在 Python 中用于打开一个文件，并确保该文件在使用完毕后被正确关闭
基本语法如下：
with open(file_path, mode, encoding=None, errors=None) as file_object:
#在这里对文件进行操作
#当离开这个代码块时，文件会自动关闭
file_path：文件的路径
mode：文件的打开模式，如'r'（只读）、'w'（写入）、'a'（追加）等。还可以添加'b'来表示二进制模式，如'rb'（二进制只读）、'wb'（二进制只写）
encoding：指定文件的编码格式，如 'utf-8'，这是可选参数，默认是系统默认编码
errors：指定如何处理编码和解码错误，如'strict'（严格模式，遇到错误就抛出异常）、'ignore'（忽略错误）等，这也是可选参数
file_object：这是打开文件后返回的文件对象，你可以用它来读取或写入文件
注：使用with open()语句时，不需要显式地调用file.close()方法来关闭文件，因为上下文管理器会在代码块执行完毕后自动关闭文件。
示例
读取文件
python
|
|
file_path = 'example.txt' |
|
|
with open(file_path, 'r', encoding='utf-8') as file: |
|
|
content = file.read() |
|
|
print(content) |
|
|
# 文件在这里已经被自动关闭 |
写入文件
python
|
|
file_path = 'example.txt' |
|
|
with open(file_path, 'w', encoding='utf-8') as file: |
|
|
file.write('Hello, world!') |
|
|
# 文件在这里已经被自动关闭 |
追加到文件
python
|
|
file_path = 'example.txt' |
|
|
with open(file_path, 'a', encoding='utf-8') as file: |
|
|
file.write('\nAnother line of text.') |
|
|
# 文件在这里已经被自动关闭 |
re.sub()语句
re.sub()是Python中re模块提供的一个函数，用于在字符串中查找与正则表达式匹配的所有子串，并将它们替换为指定的内容
基本语法如下：
re.sub(pattern, repl, string, count=0, flags=0)
pattern：正则表达式的模式和规则
repl：替换的字符串（也可为一个函数）
string：要被搜索和替换的原始字符串
count：模式匹配后替换的最大次数，默认为0，表示替换所有的匹配
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等
示例
简单替换
python
|
|
import re |
|
|
|
|
|
text = "Hello, world! Hello, Python!" |
|
|
new_text = re.sub(r"Hello", "Hi", text) |
|
|
print(new_text) # 输出: Hi, world! Hi, Python! |
使用函数进行替换
python
|
|
import re |
|
|
|
|
|
def increase_number(match): |
|
|
value = match.group() # 获取匹配的整个字符串 |
|
|
num = int(value) + 1 # 将字符串转换为整数并加1 |
|
|
return str(num) # 将结果转换回字符串 |
|
|
|
|
|
text = "There are 123 apples, 456 oranges, and 789 bananas." |
|
|
new_text = re.sub(r"\d+", increase_number, text) |
|
|
print(new_text) # 输出: There are 124 apples, 457 oranges, and 790 bananas. |
限制替换次数
python
|
|
import re |
|
|
|
|
|
text = "one fish two fish red fish blue fish" |
|
|
new_text = re.sub(r"fish", "shark", text, count=2) |
|
|
print(new_text) # 输出: one shark two shark red fish blue fish |
使用标志位
python
|
|
import re |
|
|
|
|
|
text = "Hello, World! HELLO, WORLD!" |
|
|
new_text = re.sub(r"hello", "hi", text, flags=re.IGNORECASE) |
|
|
print(new_text) # 输出: hi, World! hi, WORLD! |
在这个例子中，我们使用了re.IGNORECASE标志位来忽略大小写，因此所有的 "hello"（无论大小写）都被替换成了 "hi"。
splitlines()语句
在Python中，splitlines()方法是一个字符串方法，它用于将字符串按照行分隔符（通常是换行符\n）分割成一个列表，每个元素都是原字符串中的一行。
功能：按照行边界（\n、\r、\r\n）将字符串分割成一个列表，每一行作为列表中的一个元素。
示例：
text = "line1\nline2\rline3\r\nline4"
result = text.splitlines()
print(result)
输出：['line1', 'line2', 'line3', 'line4']
特点：
专门用于按行分割字符串，不需要指定分隔符，会自动识别行边界。
会忽略行边界字符，只保留每行的内容。
split方法更通用，可以根据任意指定的分隔符进行字符串分割，适用于各种分割需求。
splitlines方法则专注于按行分割字符串，常用于处理多行文本，如读取文件内容后按行处理等场景。在处理与行相关的操作时，splitlines更加方便和高效。
strip()语句
在Python中，strip()方法是一个字符串方法，用于移除字符串开头和结尾的所有空白字符（包括空格、制表符、换行符等）。当你看到这样的代码if line.strip():时，它的作用是对字符串line调用strip()方法，并检查移除空白字符后的字符串是否为空。
注：
在Python的print函数中，如果不指定end参数，它默认会在输出的字符串末尾添加一个换行符。
print()
功能：用于输出内容到控制台。
语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
*objects：要打印的对象，可以是多个，用逗号分隔。
sep：多个对象之间的分隔符，默认为空格。
end：打印结束后添加的字符，默认为换行符\n。
file：输出的文件对象，默认为标准输出sys.stdout。
flush：是否立即刷新输出缓冲区，默认为False。
示例：
print("Hello", "World", sep=', ', end='!')
输出：Hello, World!
可以在`print`函数中同时输出多个变量，变量之间用逗号分隔。
例如： – 输出不同类型的多个变量：
```name = "Alice" age = 25 height = 1.65
print(name, age, height) ```
当使用逗号分隔多个变量时，`print`函数会自动在变量之间添加一个空格进行分隔。如果不想要这个空格，可以将多个变量拼接成一个字符串后再输出。
例如： – 拼接字符串输出：
```name = "Bob" age = 30
print(name + " is " + str(age) + " years old.") ```
这里需要注意，当拼接数字和字符串时，要先将数字变量使用`str`函数转换为字符串类型，否则会出现类型错误。
**格式化输出变量** – **使用`%`格式化输出**（旧的格式化方式）：
例如，格式化输出整数和字符串：
```num = 5 string_var = "Python"
print("The number is %d and the string is %s."%(num, string_var)) ``` 其中`%d`用于格式化整数，`%s`用于格式化字符串。
格式字符和变量的顺序要一一对应，并且变量要放在一个元组中作为`%`操作符的参数。
**使用`format`方法格式化输出**：
例如： ```num = 7 string_var = "Programming"
print("The number is {} and the string is {}.".format(num, string_var)) ```
还可以通过指定索引来改变变量的顺序：
```print("The string is {1} and the number is {0}.".format(num, string_var)) ```
**使用f – strings（Python 3.6及以上版本）**：
例如： ```num = 9 string_var = "Language"
print(f"The number is {num} and the string is {string_var}.") ```
f – strings提供了一种简洁、直观的方式来在字符串中嵌入变量，并且可以在大括号内进行表达式计算等操作。
range()
功能：生成一个整数序列，常用于循环中控制迭代次数。
语法：
range(stop)：生成从 0 到stop – 1的整数序列。
range(start, stop[, step])：生成从start到stop – 1，步长为step的整数序列（step默认为 1）。
示例：
for i in range(5):
print(i)
输出：0 1 2 3 4
.format()方法
.format()方法是Python中字符串对象的一个方法，用于格式化字符串。它允许你构建一个字符串，其中包含“占位符”，这些占位符将被.format()方法参数中的值所替换。
.format() 方法的语法如下：
python
|
|
"{}".format(value) |
|
|
'{key}'.format(key=value) |
|
|
"{index}".format(tuple_or_list) |
|
|
"{name1} {name2}".format(name1=value1, name2=value2, …) |
|
|
"{0} {1}".format(value1, value2, …) |
字典(一种无序的数据结构)
Python中的字典（Dictionary）是一种可变容器模型，且可以存储任意类型对象，如整数、字符串、元组等，作为键值对（key-value pairs）。字典的每个元素都是一个键值对，键和值通过冒号分隔，而键值对之间通过逗号分隔，整个字典包含在花括号 {} 中。字典中的键必须是唯一的，而值则不必。
A.字典可以通过多种方式创建：
使用花括号 {}：
python
|
|
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'} |
使用 dict() 构造函数：
python
|
|
my_dict = dict(name='Alice', age=25, city='New York') |
通过两个列表（或其他可迭代对象）创建：
python
|
|
keys = ['name', 'age', 'city'] |
|
|
values = ['Alice', 25, 'New York'] |
|
|
my_dict = dict(zip(keys, values)) |
B.访问字典中的值
通过键访问字典中的值：
python
|
|
print(my_dict['name']) # 输出: Alice |
如果键不存在，Python会抛出 KeyError。为了避免这种情况，可以使用 get() 方法：
python
|
|
print(my_dict.get('name')) # 输出: Alice |
|
|
print(my_dict.get('job', 'Not specified')) # 输出: Not specified（如果'job'键不存在） |
C.修改字典中的值
通过键修改字典中的值：
python
|
|
my_dict['age'] = 26 |
|
|
print(my_dict) # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York' |
D.添加新的键值对
如果键不存在，可以直接添加新的键值对：
python
|
|
my_dict['job'] = 'Engineer' |
|
|
print(my_dict) # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'job': 'Engineer'} |
E.删除字典中的元素
使用 del 语句：
python
|
|
del my_dict['city'] |
|
|
print(my_dict) # 输出: {'name': 'Alice', 'age': 26, 'job': 'Engineer'} |
使用 pop() 方法：
python
|
|
city = my_dict.pop('city') # 如果键存在，返回其值并删除该键值对 |
|
|
print(city) # 输出: New York（如果'city'键之前存在） |
|
|
print(my_dict) # 输出: {'name': 'Alice', 'age': 26, 'job': 'Engineer'} |
pop() 方法还可以接受一个默认值参数，如果键不存在，则返回默认值而不是抛出 KeyError：
python
|
|
print(my_dict.pop('country', 'Not found')) # 输出: Not found |
F.字典的遍历
在 Python 中，for key in my_dict:与for key in my_dict.keys():是等价的，因为默认情况下for循环遍历字典时就是遍历键。
遍历键：
python
|
|
for key in my_dict: |
|
|
print(key) |
遍历值：
python
|
|
for value in my_dict.values(): |
|
|
print(value) |
遍历键值对：
python
|
|
for key, value in my_dict.items(): |
|
|
print(key, value) |
G.字典的其他方法
Keys()方法返回一个包含字典中所有键的视图对象
python
|
|
person = {'name': 'Alice', 'age': 30, 'city': 'New York'} |
|
|
keys = person.keys() |
|
|
print(keys) # 输出: dict_keys(['name', 'age', 'city']) |
|
|
# 注意：dict_keys 是一个视图对象，它反映了字典中当前的键。你可以将其转换为列表来查看或操作这些键。 |
|
|
print(list(keys)) # 输出: ['name', 'age', 'city'] |
values() 方法返回一个包含字典中所有值的视图对象
python
|
|
values = person.values() |
|
|
print(values) # 输出: dict_values(['Alice', 30, 'New York']) |
|
|
# 同样，dict_values 是一个视图对象，反映了字典中当前的值。 |
|
|
print(list(values)) # 输出: ['Alice', 30, 'New York'] |
items() 方法返回一个包含字典中所有键值对的视图对象，每个键值对以元组的形式表示
python
|
|
items = person.items() |
|
|
print(items) # 输出: dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')]) |
|
|
# dict_items 是一个视图对象，反映了字典中当前的键值对。 |
|
|
print(list(items)) # 输出: [('name', 'Alice'), ('age', 30), ('city', 'New York')] |
update() 方法用于更新字典中的键值对，如果键已经存在，则更新其对应的值；如果键不存在，则添加新的键值对
python
|
|
person.update({'job': 'Engineer', 'age': 31}) |
|
|
print(person) # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'job': 'Engineer'} |
|
|
# 注意：'age' 键的值被更新为 31。 |
也可以使用另一个字典或键值对序列（如元组列表）来更新当前字典
python
|
|
another_dict = {'country': 'USA', 'city': 'Los Angeles'} |
|
|
person.update(another_dict) |
|
|
print(person) # 输出: {'name': 'Alice', 'age': 31, 'city': 'Los Angeles', 'job': 'Engineer', 'country': 'USA'} |
|
|
# 注意：'city' 键的值被更新为 'Los Angeles'。 |
clear() 方法用于删除字典中的所有键值对，使其变为空字典
python
|
|
person.clear() |
|
|
print(person) # 输出: {} |
|
|
# 此时，person 是一个空字典。 |
copy()方法用于复制字典
python
|
|
my_dict = {"apple": 3, "banana": 5, "cherry": 2} |
|
|
new_dict = my_dict.copy() print(new_dict) # 输出{"apple": 3, "banana": 5, "cherry": 2}
|
|
|
|
列表(一种有序的数据结构)
它能够存储一系列有序的元素，这些元素可以是不同类型的。
A.创建列表
可以使用方括号[]来创建一个列表，列表中的元素用逗号分隔
python
|
|
my_list = [1, 2, 3, 4, 5] # 创建一个包含整数的列表 |
|
|
fruits = ['apple', 'banana', 'cherry'] # 创建一个包含字符串的列表 |
|
|
mixed_list = [1, 'apple', 3.14, True] # 创建一个包含不同类型元素的列表 |
B.访问元素
列表中的元素可以通过索引来访问，索引从0开始
python
|
|
print(my_list[0]) # 输出: 1，访问列表的第一个元素 |
|
|
print(fruits[2]) # 输出: cherry，访问列表的第三个元素 |
C.修改元素
可以通过索引来修改列表中的元素
python
|
|
my_list[1] = 10 # 将列表的第二个元素修改为10 |
|
|
print(my_list) # 输出: [1, 10, 3, 4, 5] |
D.添加元素
可以使用append()方法在列表的末尾添加一个元素，或者使用insert()方法在指定位置插入一个元素
python
|
|
my_list.append(6) # 在列表末尾添加元素6 |
|
|
print(my_list) # 输出: [1, 10, 3, 4, 5, 6] |
|
|
|
|
|
my_list.insert(2, 'a') # 在索引2的位置插入元素'a' |
|
|
print(my_list) # 输出: [1, 10, 'a', 3, 4, 5, 6] |
E.删除元素
你可以使用remove()方法根据值删除元素，或者使用pop()方法根据索引删除元素（并返回该元素）。此外，还可以使用del语句删除元素。
python
|
|
my_list.remove('a') # 删除值为'a'的元素 |
|
|
print(my_list) # 输出: [1, 10, 3, 4, 5, 6] |
|
|
|
|
|
last_element = my_list.pop() # 删除并返回列表的最后一个元素 |
|
|
print(last_element) # 输出: 6 |
|
|
print(my_list) # 输出: [1, 10, 3, 4, 5] |
|
|
|
|
|
del my_list[1] # 删除索引1的元素 |
|
|
print(my_list) # 输出: [1, 3, 4, 5] |
F.列表遍历
可以使用for循环来遍历列表中的元素
python
|
|
for item in my_list: |
|
|
print(item) |
|
|
# 输出: |
|
|
# 1 |
|
|
# 3 |
|
|
# 4 |
|
|
# 5 |
G.列表推导式
列表推导式是Python中一种简洁的构建列表的方法
python
|
|
squares = [x**2 for x in range(1, 6)] # 创建一个包含1到5的平方的列表 |
|
|
print(squares) # 输出: [1, 4, 9, 16, 25] |
H.列表的嵌套
列表可以包含其他列表，形成嵌套列表
python
|
|
matrix = [ |
|
|
[1, 2, 3], |
|
|
[4, 5, 6], |
|
|
[7, 8, 9] |
|
|
] |
|
|
print(matrix[1][2]) # 输出: 6，访问嵌套列表中的元素 |
元组
元组（Tuple）是Python中另一种基础的数据结构，与列表类似，但它是不可变的，即一旦创建，就不能修改其内容。元组通常用于存储不需要改变的数据集合。
A.创建元组
可以使用圆括号()来创建一个元组，元组中的元素用逗号分隔。如果只有一个元素，需要在元素后面加一个逗号来区分它是元组还是一个单独的表达式
python
|
|
my_tuple = (1, 2, 3, 4, 5) # 创建一个包含整数的元组 |
|
|
single_element_tuple = (7,) # 创建一个只有一个元素的元组，注意后面的逗号 #a = (5) # 这不是一个元组，而是一个整数5，圆括号在这里没有实际作用 |
|
|
empty_tuple = () # 创建一个空元组 |
B.访问元素
元组中的元素可以通过索引来访问，索引从0开始
python
|
|
print(my_tuple[0]) # 输出: 1，访问元组的第一个元素 |
|
|
print(my_tuple[3]) # 输出: 4，访问元组的第四个元素 |
C.不可变性
由于元组是不可变的，因此你不能像修改列表那样修改元组中的元素。如果你尝试这样做，Python会抛出一个TypeError
python
|
|
# my_tuple[1] = 10 # 这行代码会抛出TypeError，因为元组是不可变的 |
D.遍历元组
可以使用for循环来遍历元组中的元素
python
|
|
for item in my_tuple: |
|
|
print(item) |
|
|
# 输出: |
|
|
# 1 |
|
|
# 2 |
|
|
# 3 |
|
|
# 4 |
|
|
# 5 |
E.元组拆包
可以将元组中的元素赋值给多个变量，这称为元组拆包
python
|
|
a, b, c, d, e = my_tuple |
|
|
print(a) # 输出: 1 |
|
|
print(b) # 输出: 2 |
|
|
# … |
F.嵌套元组
元组可以包含其他元组，形成嵌套元组
python
|
|
nested_tuple = ((1, 2), (3, 4), (5, 6)) |
|
|
print(nested_tuple[1][1]) # 输出: 4，访问嵌套元组中的元素 |
G.作为函数返回值
由于元组是不可变的，因此它们经常用作函数的返回值，以返回多个值
python
|
|
def get_coordinates(): |
|
|
return (10.0, 20.0) |
|
|
|
|
|
x, y = get_coordinates() |
|
|
print(x, y) # 输出: 10.0 20.0 |
H.用作字典的键
由于元组是不可变的，因此它们可以用作字典的键，而列表则不能
python
|
|
my_dict = {(1, 2): 'point A', (3, 4): 'point B'} |
|
|
print(my_dict[(1, 2)]) # 输出: point A |
容器对比：略
切片
切片操作的基本语法是 [start:stop:step]，其中：
start：表示切片的起始索引（包含该索引对应的元素），如果省略则默认从开头开始（索引为 0）
stop：表示切片的结束索引（不包含该索引对应的元素），如果省略则默认到末尾结束
step：表示切片的步长，即每隔几个元素取一个，默认为 1，如果设置为负数，则表示从后往前进行切片，同样省略时默认为 1
- 提取列表中部分元素（正索引、默认步长）
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 提取索引从 2 到 5（不包含 5）的元素
result = my_list[2:5]
print(result)
解析：
start为 2，意味着从索引为 2 的元素（值为 2）开始提取
stop为 5，代表提取到索引为 5 的元素之前结束，所以实际提取的元素是索引为 2、3、4 的元素，即[2, 3, 4]
- 省略起始索引（从开头开始切片）
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 省略 start，从开头提取到索引为 5（不包含 5）的元素
result = my_list[:5]
print(result)
解析：
因为省略了start，按照默认规则从开头（索引为 0）开始提取，stop 为 5，所以会提取索引为 0、1、2、3、4 的元素，结果为[0, 1, 2, 3, 4]，代码运行输出就是这个列表。
- 省略结束索引（提取到末尾）
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 省略 stop，从索引为 3 的元素开始提取到末尾
result = my_list[3:]
print(result)
解析：
start为 3，从索引为 3 的元素（值为 3）开始提取，由于省略了 stop，就会一直提取到列表的末尾，最终结果为[3, 4, 5, 6, 7, 8, 9]，代码执行后会输出该列表
- 指定步长进行切片
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从索引为 1 开始，到索引为 8（不包含 8），步长为 2 提取元素
result = my_list[1:8:2]
print(result)
解析：
start为 1，从索引为 1 的元素（值为 1）开始。
stop为 8，提取到索引为 8 的元素之前结束。
step为 2，意味着每隔 2 个元素取一个，所以实际提取的元素是索引为 1、3、5、7 的元素，即[1, 3, 5, 7]，代码运行输出此结果
- 从后往前切片（负步长）
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从后往前，步长为 -1（即倒序提取整个列表）
result = my_list[::-1]
print(result)
解析：
这里省略了start和stop，表示对整个列表进行操作，step设置为 -1，表示从后往前逐个元素提取，相当于将列表反转，最终结果为[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]，代码运行会输出这个反转后的列表。
- 负索引结合负步长切片
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从索引为 -3（倒数第 3 个元素）开始，到索引为 -8（倒数第 8 个元素，不包含），步长为 -1（倒序）
result = my_list[-3:-8:-1]
print(result)
解析：
start为-3，对应的元素是 7（倒数第 3 个元素）。
stop为-8，按照不包含该索引对应元素的规则，实际提取到倒数第 9 个元素之前结束。
step为-1，从后往前提取，所以提取的元素是索引为 -3、-4、-5、-6、-7 的元素，即[7, 6, 5, 4, 3]，代码运行输出此列表
- 字符串的切片操作（与列表类似）
my_string = "Hello, World!"
# 提取字符串中索引从 7 到 12（不包含 12）的字符
result = my_string[7:12]
print(result)
Zfill()函数
zfill()是 Python 字符串的一个方法。它的主要作用是在字符串的左边填充零（'0'），直到字符串达到指定的长度。
字符串.zfill (width)，其中width是一个整数，表示填充后的字符串总长度。
upper()函数
upper()也是 Python 字符串的一个方法，它用于将字符串中的所有小写字母转换为大写字母。字符串.upper ()，它没有参数。
startswith()函数
startswith()是 Python 字符串的一个方法。它用于检查字符串是否以指定的前缀开头。如果字符串以该前缀开头，则返回True；否则返回False。
字符串.startswith (prefix [, start [, end]])。其中prefix是必需的参数，表示要检查的前缀；start是可选参数，指定开始检查的位置（索引），默认是 0，即从字符串的开头开始检查；end也是可选参数，指定结束检查的位置（索引），默认是字符串的长度，即检查到字符串的末尾。
read()函数
功能: read()函数用于从文件中读取指定字节数的数据。如果没有指定字节数，则会读取整个文件内容。它返回读取到的内容作为一个字符串。
示例
假设`test.txt`文件内容为`Hello, World!`
with open('test.txt', 'r') as file:
content = file.read()
print(content) # 输出: Hello, World!
注意事项:当文件非常大时，使用`read()`函数不加参数读取整个文件可能会导致内存占用过高，因为它会一次性将文件内容全部加载到内存中。
readline()函数
功能:用于从文件中读取一行内容。每次调用`readline()`，它会读取文件中的下一行，直到文件末尾。它返回读取到的一行内容作为一个字符串，如果到达文件末尾则返回空字符串。
示例
假设`test.txt`文件内容为： ``` Line 1\n Line 2\n Line 3 ```
with open('test.txt', 'r') as file:
line1 = file.readline()
line2 = file.readline()
print(line1) # 输出: Line 1\n
print(line2) # 输出: Line 2\n
readlines()函数
功能:readlines()函数用于读取文件中的所有行，并将它们作为一个列表返回。列表中的每个元素是文件中的一行内容，每行末尾的换行符`\n`也会被保留。
总结来说，`read()`适合读取文件的部分内容或小文件的全部内容；`readline()`适合逐行读取文件内容；`readlines()`适合读取文件所有行到一个列表中，但要注意大文件可能带来的内存问题。
index()函数
index()是列表（list）类型的一个内置方法，其主要作用是查找列表中某个元素第一次出现的索引位置。
split()函数
在 Python 中，split()是字符串的一个内置方法，用于将字符串分割成子字符串，并返回一个列表。
对于字符串s，其基本语法为：
s.split([sep[, maxsplit]])
其中：
sep（可选）：分隔符，用于指定按照什么字符或字符串来分割原字符串。如果不指定 sep，则默认以空格（包括空格、制表符 \t、换行符 \n 等空白字符）作为分隔符。
maxsplit（可选）：最大分割次数。如果指定了 maxsplit，则最多分割 maxsplit 次。
使用示例
（1）默认以空格分割
s = "apple banana cherry"
result = s.split()
print(result) # 输出: ['apple', 'banana', 'cherry']
（2）以指定字符分割
s = "apple,banana,cherry"
result = s.split(',')
print(result) # 输出: ['apple', 'banana', 'cherry']
（3）指定最大分割次数
s = "apple,banana,cherry"
result = s.split(',', 1)print(result) # 输出: ['apple', 'banana,cherry']
注意事项
如果字符串的开头或结尾有分隔符，split()方法会在结果列表中产生空字符串元素。
例如：
s = ",apple,banana,"
result = s.split(',')
print(result) # 输出: ['', 'apple', 'banana', '']
split() 方法不会改变原始字符串，它返回一个新的列表。
除了split()方法外，还有rsplit()方法，rsplit()与split()的区别在于，rsplit()是从字符串的末尾开始分割。在不指定 maxsplit 时，rsplit()和split()的结果相同；但在指定maxsplit时，rsplit()会从右向左进行分割。
enumerate()函数
在 Python 中，enumerate是一个内置函数。它的主要作用是将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标。
语法：enumerate(iterable, start=0)
iterable：必需参数，是一个可迭代对象，如列表、元组、字符串等。
start：可选参数，是索引的起始值，默认为 0。
使用示例
示例 1：对列表使用enumerate
假设我们有一个列表fruits = ['apple', 'banana', 'cherry']。
使用enumerate：
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
print(index, fruit)
输出：
0 apple
1 banana
2 cherry
示例 2：指定索引起始值
如果我们希望索引从 1 开始，可以这样使用enumerate：
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, start = 1):
print(index, fruit)
输出：
1 apple
2 banana
3 cherry
示例 3：在其他可迭代对象中的应用
对于字符串：
s = "abc"
for index, char in enumerate(s):
print(index, char)
输出：
0 a
1 b
2 c
copy()和deepcopy()函数区别
- 浅拷贝（copy）
定义和原理:`copy()`方法（对于如列表、字典、集合等数据结构）或者`copy.copy()`函数会创建一个新的对象，但新对象中的元素是原始对象元素的引用。
示例
以列表为例
假设我们有一个包含列表的列表作为原始对象
import copy
original_list = [1, 2, [3, 4]]
shallow_copied_list = copy.copy(original_list)
当我们修改原始列表中的不可变元素（如整数）时，浅拷贝后的列表不受影响。但如果修改原始列表中的可变元素（如嵌套的列表），浅拷贝后的列表也会改变： original_list[0] = 5
original_list[2][0] = 6
print("Original List after modification:", original_list) print("Shallow Copied List after modification:", shallow_copied_list) ``` – 输出为： ```
Original List after modification: [5, 2, [6, 4]]
Shallow Copied List after modification: [1, 2, [6, 4]]
- 深拷贝（deepcopy）
定义和原理:copy.deepcopy()函数会创建一个全新的对象，并且递归地复制原始对象中的所有元素，包括可变的子对象。它会在内存中为新对象及其所有子对象重新分配内存空间，新对象和原始对象完全独立，对其中一个的修改不会影响另一个。
示例
同样以列表为例
对于之前的例子，如果我们使用深拷贝：
import copy
original_list = [1, 2, [3, 4]]
deep_copied_list = copy.deepcopy(original_list)
original_list[2][0] = 6
print("Original List after modification:", original_list)
print("Deep Copied List after modification:", deep_copied_list)
输出为：
Original List after modification: [1, 2, [6, 4]]
Deep Copied List after modification: [1, 2, [3, 4]]
适用场景总结:
浅拷贝适用场景-当你只需要复制对象的外层结构，并且不介意共享内部可变子对象时可以使用浅拷贝。例如，如果你有一个列表，其中的元素都是不可变类型（如整数、字符串），或者你希望对内部可变子对象的修改能够同时反映在原始对象和拷贝对象中，那么浅拷贝是一个合适的选择。
深拷贝适用场景-当你需要完全独立的对象副本，特别是对象包含多层嵌套的可变数据结构，并且希望对副本的任何修改都不会影响原始对象时，应该使用深拷贝。例如，在保存对象状态的备份或者在复杂的对象树结构中需要独立操作副本时，深拷贝是更好的方法。
map()函数
在Python中，`map()`函数的主要作用是对一个可迭代对象（如列表、元组等）中的每个元素应用一个指定的函数，并返回一个包含结果的新的可迭代对象。这个函数可以是Python内置函数、自定义函数或者匿名函数（lambda函数）。
基本语法:
map(function, iterable,…)
其中`function`是要应用到每个元素的函数，`iterable`是一个或多个可迭代对象。如果有多个可迭代对象，那么`function`函数需要接收对应个数的参数，并且`map()`函数会并行地从这些可迭代对象中获取元素并应用函数
示例及应用场景:
对列表元素进行简单运算
例如，对一个整数列表中的每个元素求平方：
my_list = [1, 2, 3, 4, 5]
squared_list = map(lambda x: x * x, my_list)
print(list(squared_list))
输出为`[1, 4, 9, 16, 25]`
对多个列表的元素进行操作
假设我们有两个列表，一个是数字列表，一个是对应的系数列表，想要计算每个数字乘以其系数的结果：
numbers = [2, 4, 6]
coefficients = [3, 5, 7]
results = map(lambda x, y: x * y, numbers, coefficients) print(list(results))
输出为`[6, 20, 42]`
数据类型转换
例如，将一个字符串列表中的每个字符串转换为整数：
str_list = ["1", "2", "3"]
int_list = map(int, str_list)
print(list(int_list))
输出为`[1, 2, 3]`
os.walk()
os.walk()是 Python 中os模块提供的一个用于遍历目录树的函数，以下是它的详细介绍：
语法
os.walk(top, topdown=True, onerror=None, followlinks=False)
参数说明
top：必选参数，要遍历的根目录路径，可以是字符串形式的绝对路径或相对路径。
topdown：可选参数，默认为True。如果为True，则首先遍历根目录（top），然后递归遍历其子目录；如果为False，则先递归遍历子目录，再遍历根目录。
onerror：可选参数，用于指定一个错误处理函数。当在遍历过程中发生错误（如权限问题等）时，会调用这个函数来处理错误。如果不指定该参数，默认会抛出异常。
followlinks：可选参数，默认为False。如果为False，则不跟随符号链接；如果为True，则会跟随符号链接进行遍历，但这可能会导致无限递归等问题，需要谨慎使用。
返回值
os.walk()返回一个生成器，每次迭代会产生一个三元组(root, dirs, files)：
示例
以下是一个简单的示例，展示如何使用os.walk()遍历目录并打印出所有文件和目录的路径：
import os
for root, dirs, files in os.walk('/path/to/directory'):
for dir in dirs:
print(os.path.join(root, dir))
for file in files:
print(os.path.join(root, file))
在这个示例中，os.walk('/path/to/directory')会从/path/to/directory开始遍历目录树，对于每个目录，会打印出该目录下的所有子目录和文件的完整路径。
PyQt5
什么是 PyQt5？
PyQt5 是 Python 的图形用户界面 (GUI) 框架，它基于强大的 Qt 库。Qt 是一个跨平台的 C++ 框架，用于构建桌面应用程序。通过 PyQt5，我们可以用 Python 轻松构建跨平台的桌面应用程序，支持 Windows、macOS 和 Linux。
创建简单的窗口应用
导入必要的模块
在 Python 脚本中，首先要导入 PyQt5 的相关模块。最基本的是QtWidgets模块，它包含了创建用户界面所需的各种组件，如窗口、按钮、标签等。
import sys
from PyQt5.QtWidgets import QApplication, QWidget
QApplication类用于管理应用程序的控制流和主要设置，QWidget是所有用户界面对象的基类，窗口也是一种QWidget。
创建应用程序和窗口对象
创建QApplication实例，它接收命令行参数（通常是sys.argv）。
创建QWidget实例作为主窗口。
app = QApplication(sys.argv)
window = QWidget()
设置窗口属性和显示窗口
可以设置窗口的标题、大小等属性。例如，设置窗口标题为"My First PyQt5 Window"，大小为400×300像素。
window.setWindowTitle("My First PyQt5 Window")
window.setGeometry(100, 100, 400, 300)
window.show()
最后，通过app.exec_()进入应用程序的主循环，这个循环会一直运行，直到窗口关闭。
sys.exit(app.exec_())
添加部件（Widgets）到窗口
按钮（QPushButton）示例
导入QPushButton类
from PyQt5.QtWidgets import QPushButton
在创建窗口后，添加一个按钮到窗口。
app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Window with Button")
window.setGeometry(100, 100, 400, 300)
button = QPushButton("Click Me", window)
button.move(150, 120)
window.show()
sys.exit(app.exec_())
这里创建了一个名为"Click Me"的按钮，将其添加到window对象中，并通过move方法设置了按钮在窗口中的位置。
标签（QLabel）示例
导入QLabel类。
from PyQt5.QtWidgets import QLabel
创建标签并添加到窗口。
app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Window with Label")
window.setGeometry(100, 100, 400, 300)
label = QLabel("This is a label", window)
label.move(150, 100)
window.show()
sys.exit(app.exec_())
这个标签显示了文本"This is a label"，并在窗口中有相应的位置。
信号与槽（Signals and Slots）机制
基本概念
信号是对象发出的事件通知，例如按钮被点击时会发出clicked信号。槽是接收到信号后执行的函数或方法。通过将信号连接到槽，可以实现事件驱动的编程。
示例：按钮点击事件
定义一个函数作为槽。
def button_clicked():
print("Button clicked!")
将按钮的clicked信号连接到这个槽。
app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Signal and Slot Example")
window.setGeometry(100, 100, 400, 300)
button = QPushButton("Click Me", window)
button.move(150, 120)
button.clicked.connect(button_clicked)
window.show()
sys.exit(app.exec_())
当按钮被点击时，button_clicked函数会被调用，在控制台输出"Button clicked!"。
布局管理（Layout Management）
布局的重要性
布局管理器可以自动排列窗口中的部件，使得界面在不同的窗口大小下都能保持良好的外观。常见的布局管理器有QVBoxLayout（垂直布局）、QHBoxLayout（水平布局）和QGridLayout（网格布局）。
垂直布局示例（QVBoxLayout）
导入布局管理器类。
from PyQt5.QtWidgets import QVBoxLayout
创建布局，添加部件到布局，然后将布局设置给窗口。
app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Vertical Layout Example")
window.setGeometry(100, 100, 400, 300)
layout = QVBoxLayout()
button1 = QPushButton("Button 1")
button2 = QPushButton("Button 2")
layout.addWidget(button1)
layout.addWidget(button2)
window.setLayout(layout)
window.show()
sys.exit(app.exec_())
这里创建了一个垂直布局，添加了两个按钮，然后将布局应用到窗口，按钮会自动垂直排列。
【Python篇】PyQt5 超详细教程——由入门到精通（序篇）-CSDN博客
QWidget和QMainWindow的区别
一、基本概念
QWidget：
-
- QWidget是 PyQt5（以及 Qt 框架）中所有用户界面对象的基类。它可以作为一个独立的窗口，也可以作为其他部件的容器，用于构建复杂的用户界面。
- 你可以将各种部件（如按钮、标签、文本框等）添加到 QWidget 中，并通过布局管理器对它们进行布局。
QMainWindow：
-
- QMainWindow 是一种特殊的 QWidget，它专门设计用于创建主窗口应用程序。它具有一些预定义的布局，包含了菜单栏、工具栏、状态栏等常见的主窗口元素。
二、布局和功能差异
QWidget 布局：
-
- 当你使用 QWidget 作为窗口时，它的布局相对灵活。你可以根据需要自由添加各种部件，并使用布局管理器（如 QVBoxLayout、QHBoxLayout、QGridLayout）进行布局。
QMainWindow 布局：
-
- QMainWindow 具有一个预定义的布局，包含中央部件区域、菜单栏、工具栏和状态栏。
- 例如，创建一个 QMainWindow 并添加菜单栏和中央部件：
import sysfrom PyQt5.QtWidgets import QApplication, QMainWindow, QAction, QLabel, QVBoxLayout, QWidget
app = QApplication(sys.argv)
mainWindow = QMainWindow()
mainWindow.setWindowTitle("QMainWindow Example")
# 创建菜单栏
menuBar = mainWindow.menuBar()
fileMenu = menuBar.addMenu("File")
exitAction = QAction("Exit", mainWindow)
fileMenu.addAction(exitAction)
# 创建中央部件
centralWidget = QWidget()
layout = QVBoxLayout(centralWidget)
label = QLabel("This is the central widget")
layout.addWidget(label)
mainWindow.setCentralWidget(centralWidget)
mainWindow.show()
sys.exit(app.exec_())
这里使用 QMainWindow 的 menuBar() 方法添加了一个菜单栏，然后使用 setCentralWidget() 方法添加了一个中央部件。
三、使用场景
QWidget 使用场景：
-
- 当你需要创建简单的窗口，或者将其作为其他部件的容器时，使用 QWidget。
- 例如，创建一个对话框、弹出窗口，或者一个自定义的部件，都可以使用 QWidget。
QMainWindow 使用场景：
-
- 当你开发一个完整的应用程序，需要菜单栏、工具栏、状态栏等常见的主窗口元素时，使用 QMainWindow。
- 例如，开发一个文本编辑器、图像处理软件、办公软件等，通常会使用 QMainWindow 作为主窗口，因为它提供了一个完整的框架，可以方便地添加各种主窗口元素。
四、继承关系
QMainWindow 是 QWidget 的子类，因此 QMainWindow 继承了 QWidget 的所有特性，但它添加了一些额外的功能和预定义的布局，以满足主窗口应用程序的需求。
类
一、构造函数（__init__）
在 Python 中，构造函数是一个特殊的方法，用于在创建对象时初始化对象的状态。它的名称是 __init__，并接收 self 参数（表示对象本身）以及其他可选参数。
class MyClass:
def __init__(self, value=0):
self.value = value # 初始化对象的属性
# 创建对象
obj = MyClass(10)
print(obj.value) # 输出 10
二、析构函数（__del__）
析构函数是 __del__ 方法，当对象被销毁时调用。然而，在 Python 中，析构函数的使用相对较少，因为 Python 有自动的垃圾回收机制。
class MyClass:
def __init__(self, value=0):
self.value = value
def __del__(self):
print(f"Deleting object with value {self.value}")
# 创建和删除对象
obj = MyClass(10)
del obj # 输出 "Deleting object with value 10"
__del__ 通常用于释放对象占用的资源，但由于 Python 的垃圾回收机制，你无法确切知道对象何时被销毁。
三、拷贝构造函数和拷贝赋值函数
Python 没有内置的拷贝构造函数，但可以使用 copy 模块来实现对象的浅拷贝和深拷贝。
浅拷贝：
import copy
class MyClass:
def __init__(self, value=0):
self.value = value
obj1 = MyClass(10)
obj2 = copy.copy(obj1) # 浅拷贝print(obj1.value) # 输出 10print(obj2.value) # 输出 10
深拷贝：
import copy
class MyClass:
def __init__(self, value=0):
self.value = value
obj1 = MyClass(10)
obj2 = copy.deepcopy(obj1) # 深拷贝print(obj1.value) # 输出 10print(obj2.value) # 输出 10
四、移动构造函数和移动赋值函数
Python 是一种解释型语言，具有自动内存管理，因此没有 C++ 中那样的移动语义和移动构造函数或移动赋值函数。
五、封装
封装是将数据和操作数据的方法包装在一个单元（类）中，并限制对数据的访问，以确保数据的安全性和一致性。在 Python 中，可以使用属性和方法来实现封装。
class MyClass:
def __init__(self, value=0):
self._value = value # 约定使用单下划线表示受保护的属性
def get_value(self): # 读取属性的方法
return self._value
def set_value(self, value): # 修改属性的方法
self._value = value
obj = MyClass(10)print(obj.get_value()) # 输出 10
obj.set_value(20)print(obj.get_value()) # 输出 20
六、继承
在 Python 中，继承是通过在定义类时将父类放在类名后面的括号内来实现的。
Python 支持多重继承，即一个类可以继承多个父类。
class ParentClass1:
def method1(self):
print("Method from ParentClass1")
class ParentClass2:
def method2(self):
print("Method from ParentClass2")
class ChildClass(ParentClass1, ParentClass2):
def child_method(self): print("Child method")
# 创建子类的实例
child_obj = ChildClass()
child_obj.method1() # 调用 ParentClass1 的方法
child_obj.method2() # 调用 ParentClass2 的方法
child_obj.child_method() # 调用子类的方法
继承允许一个类（子类）继承另一个类（父类）的属性和方法，以实现代码的重用和扩展。
class ParentClass:
def __init__(self, value=0):
self.value = value
def show_value(self):
print(f"Value: {self.value}")
class ChildClass(ParentClass):
def __init__(self, value=0, extra_value=0):
super().__init__(value) # 调用父类的构造函数
self.extra_value = extra_value
def show_extra_value(self):
print(f"Extra Value: {self.extra_value}")
child_obj = ChildClass(10, 20)
child_obj.show_value() # 输出 "Value: 10"
child_obj.show_extra_value() # 输出 "Extra Value: 20"
七、多态
多态允许不同的对象使用相同的接口（方法），但实现不同的行为。在 Python 中，多态通常通过方法重写来实现。
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow!"
def animal_sound(animal):
print(animal.speak())
dog = Dog()
cat = Cat()
animal_sound(dog) # 输出 "Woof!"
animal_sound(cat) # 输出 "Meow!"
Dog 和 Cat 都继承自 Animal，并实现了 speak 方法，但它们的行为不同。
八、容器
Python 提供了各种内置的容器类型，如列表（list）、元组（tuple）、字典（dict）和集合（set），用于存储和管理数据。
列表（list）：
my_list = [1, 2, 3] # 可存储任意类型的数据
my_list.append(4) # 添加元素print(my_list) # 输出 [1, 2, 3, 4]
元组（tuple）：
my_tuple = (1, 2, 3) # 不可变print(my_tuple[0]) # 输出 1
字典（dict）：
my_dict = {'a': 1, 'b': 2} # 存储键值对
my_dict['c'] = 3 # 添加键值对print(my_dict) # 输出 {'a': 1, 'b': 2, 'c': 3}
集合（set）：
my_set = {1, 2, 3} # 存储唯一元素
my_set.add(4) # 添加元素print(my_set) # 输出 {1, 2, 3, 4}
九、特殊方法（魔术方法）
Python 类可以定义特殊方法，这些方法以双下划线开头和结尾，如 __str__、__len__、__add__ 等，用于自定义对象的行为。
class MyClass:
def __init__(self, value=0):
self.value = value
def __str__(self):
return f"MyClass with value {self.value}"
obj = MyClass(10)print(obj) # 输出 "MyClass with value 10"
十、类方法和静态方法
类方法：使用 @classmethod 装饰器，接收 cls 参数，可访问类级别的属性和方法。
class MyClass:
class_attr = 0
@classmethod
def class_method(cls):
cls.class_attr += 1
print(f"Class attribute value: {cls.class_attr}")
MyClass.class_method() # 输出 "Class attribute value: 1"
静态方法：使用 @staticmethod 装饰器，不接收 self 或 cls 参数，类似于普通函数。
class MyClass:
@staticmethod
def static_method():
print("This is a static method")
MyClass.static_method() # 输出 "This is a static method"
总结：
self 不可以省略的原因
Python 不会自动将方法调用绑定到实例上，它使用 self 参数将方法调用绑定到实例。当你调用 obj.method() 时，Python 会将 obj 作为 self 参数传递给 method 方法。
class MyClass:
def method(self):
print("Hello")
obj = MyClass()
obj.method() # 等同于 MyClass.method(obj)
如果你不使用 self，Python 无法知道该方法应该操作哪个实例的数据，会导致错误。
在 Python 类中，参数可以在不同的地方定义，具体取决于你想要实现的功能。以下是几种情况：
一、在构造函数 __init__ 中定义实例参数
通常，类的实例参数在 __init__ 方法中定义，这是最常见的方式，因为 __init__ 是类的构造函数，用于初始化实例的状态。
class MyClass:
def __init__(self, param1, param2):
self.param1 = param1
self.param2 = param2
# 创建实例时传递参数
obj = MyClass(10, 20)print(obj.param1) # 输出 10print(obj.param2) # 输出 20
self.param1 = param1 和 self.param2 = param2 ：将传入的参数存储为实例的属性，以便在类的其他方法中使用。
二、类属性
类属性是属于类本身而不是实例的属性，它们在类的定义中直接定义，而不是在 __init__ 方法中。
class MyClass:
class_param = 0 # 类属性，属于类的所有实例共享
def __init__(self, param1):
self.param1 = param1
# 访问类属性print(MyClass.class_param) # 输出 0
# 创建实例
obj1 = MyClass(10)
obj2 = MyClass(20)
# 类属性可以通过类或实例访问，但修改时要注意print(obj1.class_param) # 输出 0print(obj2.class_param) # 输出 0
MyClass.class_param = 5print(obj1.class_param) # 输出 5print(obj2.class_param) # 输出 5
class_param 是类属性，它是类的一部分，所有实例共享这个属性。
三、方法参数
类的方法可以接受额外的参数，这些参数在方法定义中定义，除了 self（对于实例方法）或 cls（对于类方法）。
class MyClass:
def __init__(self, param1):
self.param1 = param1
def method1(self, param2): # param2 是方法的参数
print(f"param1: {self.param1}, param2: {param2}")
obj = MyClass(10)
obj.method1(20) # 输出 "param1: 10, param2: 20"
四、静态方法和类方法的参数
静态方法（使用 @staticmethod 装饰器）不接收 self 或 cls，因为它们不依赖于类或实例的状态。
class MyClass:
@staticmethod
def static_method(param1):
print(f"Static method with param: {param1}")
MyClass.static_method(10) # 输出 "Static method with param: 10"
类方法（使用 @classmethod 装饰器）接收 cls 参数，代表类本身。
class MyClass:
class_param = 0
@classmethod
def class_method(cls, param1):
print(f"Class method with param: {param1}, class param: {cls.class_param}")
MyClass.class_method(10) # 输出 "Class method with param: 10, class param: 0"
get()
在 Python 中，get 是字典（dict）数据类型的一个方法，用于获取字典中指定键的值。它的语法如下：
dict.get(key[, default])
key：必需参数，是要获取值的键。
default：可选参数，如果指定的 key 不存在于字典中，将返回该默认值。如果省略 default，则当 key 不存在时，返回 None。
以下是一些使用示例：
my_dict = {'name': 'Alice', 'age': 30}
# 获取存在的键的值
name = my_dict.get('name')
print(name) # 输出: Alice
# 获取不存在的键的值，不提供默认值
none_value = my_dict.get('city')
print(none_value) # 输出: None
# 获取不存在的键的值，提供默认值
city = my_dict.get('city', 'Unknown City')
print(city) # 输出: Unknown City
与直接通过键访问的对比
通常，可以通过 dict[key] 的方式获取字典中键对应的值，但这种方式在键不存在时会引发 KeyError 异常。而 get 方法更安全，不会引发异常，而是返回 None 或指定的默认值。
my_dict = {'name': 'Bob'}
# 直接通过键访问，键不存在时会引发异常# value = my_dict['age'] # 这行代码会引发 KeyError: 'age'
# 使用 get 方法，键不存在时返回默认值
value = my_dict.get('age', 0)
print(value) # 输出: 0
append()
在 Python 中，append()是列表（list）类型的一个内置方法。它用于在列表的末尾添加一个新的元素。这是一种非常方便的方法来动态地扩展列表的长度。
语法格式
其基本语法为：list.append(element)，其中list是要添加元素的列表，element是要添加到列表末尾的元素。这个元素可以是任何数据类型，如数字、字符串、另一个列表、字典等。
简单示例
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # 输出：[1, 2, 3, 4]
添加不同类型的元素
-
- 添加字符串元素
fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits) # 输出：["apple", "banana", "cherry"]
-
- 添加列表元素（嵌套列表）
main_list = [1, 2]
sub_list = [3, 4]
main_list.append(sub_list)
print(main_list) # 输出：[1, 2, [3, 4]]
-
- 添加字典元素（注意字典的可变性质）
my_list = []
my_dict = {"name": "John", "age": 30}
my_list.append(my_dict)
print(my_list) # 输出：[{"name": "John", "age": 30}]
注意事项
append()方法会直接修改原始列表，而不会返回一个新的列表。如果尝试将append()的结果赋值给一个新的变量，新变量会得到None，因为append()没有返回值（它是一个在原列表上进行修改的方法）。
例如：
my_list = [1, 2, 3]
new_list = my_list.append(4)
print(new_list) # 输出：None
print(my_list) # 输出：[1, 2, 3, 4]
爬虫
爬虫(spider，又网络爬虫)，是一种按照一定规则，自动抓取互联网信息的程序或者脚本。
爬虫的本质是模拟浏览器打开网页，获取网页中我们想要的那部分数据。
Python爬虫架构主要由五个部分组成，分别是调度器、URL管理器、网页下载器、网页解析器、应用程序（爬取的有价值数据）。
网页：一份网页文档是交给浏览器显示的简单文档。
这种文档是由超文本标记语言HTML来编写的，网页文档可以插入各种各样不同类型的资源：
UserAgent中文名为用户代理，是一个特殊字符串头，使得服务器能够识别客户使用的操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等的一个标识。
URL的组成：
1）协议部分(http:):它表示浏览器必须使用的协议来请求资源（协议是在计算机网络中交换或传输数据的一套方法），通常对于网站，协议是 HTTPS 或 HTTP（其不安全版本）。这里使用的是HTTP协议,在"HTTP"后面的“//”为分隔符；
2）域名部分（www.example.com）：一个URL中，也可以直接使用IP地址；
3）端口部分（80）：域名和端口之间使用“:”作为分隔符。端口不是一个URL必须的部分，如果省略端口部分，将采用默认端口(默认端口可以省略)。
4）资源路径：资源路径包含,虚拟目录部分和文件名部分
虚拟目录部分（/path/to/）：从域名后的第一个“/”开始到最后一个“/”为止，是虚拟目录部分。虚拟目录也不是一个URL必须的部分。
文件名部分（myfile.html）：从域名后的最后一个“/”开始到“？”为止，是文件名部分，如果没有“?”,则是从域名后的最后一个“/”开始到“#”为止，是文件部分。
6）参数部分（key1=value1&key2=value2）：从“？”开始到“#”为止之间的部分为参数部分，又称搜索部分、查询部分。
7）锚部分（SomewhereInTheDocument）：从“#”开始到最后，都是锚部分。锚点代表资源内的一种“书签”，为浏览器提供显示位于该“书签”位置的内容的方向。例如，在 HTML 文档中，浏览器将滚动到定义锚点的位置；在视频或音频文档上，浏览器将尝试转到锚点所代表的时间。
URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。URL是uniform resource locator，统一资源定位器，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。
1.发起请求：通过HTTP库向目标站点发起请求，即发送一个Request，请求可以包含额外的headers等信息，等待服务器响应。
常见的请求方法有两种，GET和POST。get请求是把参数包含在了URL（Uniform Resource Locator，统一资源定位符）里面，而post请求大多是在表单里面进行，也就是让你输入用户名和秘密，在url里面没有体现出来，这样更加安全。post请求的大小没有限制，而get请求有限制，最多1024个字节。
2.获取响应内容：如果服务器能正常响应，会得到一个Response，Response的内容便是所要获取的页面内容，类型可能有HTML，Json字符串，二进制数据（如图片视频）等类型。
3.解析内容：得到的内容可能是HTML，可以用正则表达式、网页解析库进行解析。可能是Json，可以直接转为Json对象解析，可能是二进制数据，可以做保存或者进一步的处理。
在Python语言中，我们经常使用Beautiful Soup、pyquery、Ixml等库，可以高效的从中获取网页信息，如节点的属性、文本值等
4.保存数据：如果数据不多，可保存在txt文本、csv文本或者json文本等。如果爬取的数据条数较多，可以考虑将其存储到数据库中。也可以保存为特定格式的文件。
urllib.request和requests库都是 Python 中用于进行网络请求的工具，但它们在使用方式、功能特性等方面存在一些区别，具体如下：
易用性
urllib.request：是 Python 标准库的一部分，无需额外安装。但它的 API 相对较为底层，使用起来相对复杂。例如，要发送一个简单的 GET 请求并获取响应内容，需要创建Request对象，再使用urlopen方法来打开请求，代码如下：
import urllib.request
url = 'https://www.example.com'
req = urllib.request.Request(url)
response = urllib.request.urlopen(req)
data = response.read().decode('utf-8')
requests：是第三方库，需要额外安装。它的 API 设计得更加简洁直观，使用起来更加方便。发送同样的 GET 请求，代码更加简洁易懂：
import requests
url = 'https://www.example.com'
response = requests.get(url)
data = response.text
功能特性
urllib.request：提供了基本的网络请求功能，如发送 GET、POST 请求等。同时支持处理一些常见的 HTTP 功能，如设置请求头、处理 Cookie 等，但需要手动进行更多的操作。
requests：功能更加强大，不仅支持各种 HTTP 请求方法（GET、POST、PUT、DELETE 等），还提供了更高级的功能，如自动处理重定向、支持 Session 会话、文件上传、下载进度跟踪等。例如，使用requests进行文件下载并跟踪进度可以这样实现：
import requests
url = 'https://example.com/file.zip'
response = requests.get(url, stream=True)
total_size = int(response.headers.get('content-length', 0))
block_size = 1024with open('file.zip', 'wb') as f:
for data in response.iter_content(block_size):
f.write(data)
对 HTTP 协议的支持
urllib.request：对 HTTP 协议的支持相对较为基础，虽然能够满足大部分基本需求，但对于一些复杂的 HTTP 特性的支持可能不够完善。
requests：对 HTTP 协议的支持非常全面，能够很好地处理各种 HTTP 状态码、请求头、响应头，并且符合最新的 HTTP 标准，在处理复杂的网络请求场景时更加可靠。
灵活性
urllib.request：相对来说灵活性较低，在处理一些特殊的网络请求或需要对请求进行深度定制时，可能会比较困难。
requests：具有更高的灵活性，通过各种参数和方法，可以轻松地对请求进行定制，如设置超时时间、代理服务器、认证信息等。例如，设置代理服务器的代码如下：
import requests
url = 'https://www.example.com'
proxies = {
'http': 'http://proxy.example.com:8080',
'https': 'https://proxy.example.com:8080'}
response = requests.get(url, proxies=proxies)
- request模块提供了最基本的构造 HTTP 请求的方法，利用它可以模拟浏览器的一个请求发起过程。
urllib.request.urlopen() 函数
打开一个url方法，返回一个文件对象HttpResponse。urlopen默认会发送get请求，当传入data参数时，则会发起POST请求。
urlopen() 返回对象HTTPResponse提供的方法和属性:
1)read()、readline()、readlines()、fileno()、close()：对 HTTPResponse 类型数据进行操作；
2)info()：返回 HTTPMessage 对象，表示远程服务器 返回的头信息 ；
3)getcode()：返回 HTTP 状态码 geturl()：返回请求的 url；
4)getheaders()：响应的头部信息;
5)status：返回状态码；
6)reason：返回状态的详细信息.
- urllib.error 模块为 urllib.request 所引发的异常定义了异常类，基础异常类是 URLError。
状态代码的第一个数字代表当前响应的类型：
1xx消息——请求已被服务器接收，继续处理
2xx成功——请求已成功被服务器接收、理解、并接受
3xx重定向——需要后续操作才能完成这一请求
4xx请求错误——4xx类的状态码用于看起来客户端有错误的情况下，请求含有词法错误或者无法被执行
5xx服务器错误——由数字“5”打头的响应状态码表示服务器已经明显处于错误的状况下或没有能力执行请求，或在处理某个正确请求时发生错误。
- BeautifulSoup4
BeautifulSoup(markup, features)接受两个参数：
第一个参数（markup）：文件对象或字符串对象
第二个参数（features）：解析器，未指定则使用python标准解析器（html.parser），但会产警告
- re标准库（模块）
在 Python 的BeautifulSoup库中，通常使用的是find_all方法，而findAll和findall可能会造成一些混淆，下面是它们的区别：
find_all
这是BeautifulSoup库中的标准方法，用于在 HTML 或 XML 文档中查找所有符合指定条件的元素。它的第一个参数是要查找的标签名，可以是字符串、正则表达式、列表等，第二个参数可以用于指定属性等其他条件。例如：soup.find_all('a', href=True)会查找所有带有href属性的<a>标签。
返回值是一个包含所有匹配元素的列表，方便对多个元素进行统一处理，比如遍历获取每个元素的文本内容或属性值等。
findAll
在早期的BeautifulSoup版本中，曾经使用findAll作为查找所有匹配元素的方法，但在BeautifulSoup 4及后续版本中，官方推荐使用find_all，findAll虽然可能仍然可用，但属于不规范的用法，不建议使用，在未来的版本中可能会被移除。
Findall
findall不是BeautifulSoup库中的方法，而是 Python 标准库中re模块（正则表达式模块）中的方法，用于在字符串中查找所有匹配指定正则表达式模式的子串。例如：re.findall(r'\d+', 'abc123def456')会返回['123', '456']。
它与BeautifulSoup中的find_all方法作用不同，findall主要用于处理字符串中的正则表达式匹配，而find_all用于在 HTML 或 XML 文档结构中查找元素。
在 Python 网络爬虫以及处理网页数据等场景中，text和content通常有以下区别：
数据类型
text：一般返回的是字符串类型的数据。它是对获取到的网页内容或其他文本数据进行解码后得到的字符串，方便人们直接阅读和处理文本信息，例如查找特定字符串、进行文本分析等。
content：通常返回的是字节类型的数据。它代表了从网络或其他来源获取到的原始二进制内容，没有经过字符编码的转换，保留了数据的原始格式，可能包含各种二进制数据，如图像、音频、视频等数据的原始字节流，也可以是网页的原始 HTML 字节数据。
应用场景
text
文本处理：当需要对网页中的文本内容进行提取、分析、搜索、替换等操作时，text非常方便。比如提取网页中的文章正文、查找特定的关键词、统计文本出现的次数等。
数据展示：如果只是想将获取到的信息以人类可读的形式展示出来，例如在终端打印网页的文本内容，使用text可以直接输出清晰的文本。
文本解析：在进行自然语言处理、文本挖掘等任务时，text提供了直接可处理的文本数据，便于使用各种文本处理库和算法进行操作。
content
文件保存：当需要将获取到的数据保存为文件，如图像、音频、视频文件等时，content可以直接用于写入文件，确保文件的二进制内容完整无误。
二进制数据处理：对于一些需要处理二进制数据的场景，如分析网络数据包、处理加密数据等，content提供了原始的字节数据，便于进行底层的二进制操作。
自定义解码：如果需要对获取到的数据进行自定义的字符编码转换或处理，可以先使用content获取原始字节数据，然后根据具体需求进行解码操作。
示例
以下是使用requests库获取网页内容时，text和content的示例：
import requests
response = requests.get('https://www.example.com')
# 使用text获取字符串内容
text_content = response.textprint(text_content)
# 使用content获取字节内容
byte_content = response.contentprint(byte_content)
在这个示例中，response.text会返回网页的字符串内容，而response.content会返回网页的原始字节内容。
JSON 相关函数
Python 的 json 模块提供了多个用于处理 JSON 数据的函数，下面详细介绍几个常用的函数：
1. json.loads()
功能：将 JSON 格式的字符串解析为 Python 对象。
示例：
import json
json_str = '{"name": "John", "age": 30, "city": "New York"}'
data = json.loads(json_str)
print(type(data)) # 输出: <class 'dict'>
print(data) # 输出: {'name': 'John', 'age': 30, 'city': 'New York'}
2. json.load()
功能：从文件对象中读取 JSON 数据，并将其解析为 Python 对象。
示例：
import json
# 假设文件 'data.json' 内容为: {"name": "Alice", "age": 25}
with open('data.json', 'r') as f:
data = json.load(f)
print(type(data)) # 输出: <class 'dict'>
print(data) # 输出: {'name': 'Alice', 'age': 25}
3. json.dumps()
功能：将 Python 对象转换为 JSON 格式的字符串。
示例：
import json
data = {'name': 'Bob', 'age': 35, 'city': 'Los Angeles'}
json_str = json.dumps(data)
print(type(json_str)) # 输出: <class 'str'>
print(json_str) # 输出: {"name": "Bob", "age": 35, "city": "Los Angeles"}
可选参数：
indent：用于指定缩进的空格数，使生成的 JSON 字符串更具可读性。
ensure_ascii：如果设置为 False，可以正确处理非 ASCII 字符。
import json
data = {'name': '张三', 'age': 28}
json_str = json.dumps(data, indent=4, ensure_ascii=False)
print(json_str)
4. json.dump()
功能：将 Python 对象转换为 JSON 格式的字符串，并写入文件对象中。
示例：
import json
data = {'name': 'Eve', 'age': 22, 'city': 'Chicago'}
with open('output.json', 'w') as f:
json.dump(data, f, indent=4)
此代码会把 Python 字典 data 转换为 JSON 字符串，然后写入 output.json 文件，并且使用 4 个空格进行缩进。
try – except 用法解释
在 Python 中，try – except 语句用于异常处理，其基本语法结构及作用如下：
基本语法
try:
# 可能会引发异常的代码块
# 在这里放置你认为可能出现错误的语句
result = 10 / 0 # 这里会引发 ZeroDivisionError 异常
except ZeroDivisionError:
# 当捕获到指定类型的异常时执行的代码块
print("除数不能为零")
执行逻辑
- try 代码块执行：程序首先执行 try 子句中的代码。如果在执行过程中没有发生异常，那么 except 子句将被跳过，程序继续执行 try – except 语句之后的代码。
- 异常发生：若在 try 代码块中发生了异常，程序会立即停止执行 try 中剩余的代码，并跳转到 except 子句。
- except 代码块执行：根据异常的类型，找到与之匹配的 except 子句并执行其中的代码。如果有多个 except 子句，会按照顺序依次检查异常类型是否匹配，只执行第一个匹配的 except 子句。
- 异常未捕获：如果发生的异常类型与所有 except 子句中指定的类型都不匹配，异常将继续向上层调用栈传递，若最终没有被捕获，程序会终止并显示默认的异常信息。
捕获多种异常
可以使用多个 except 子句来捕获不同类型的异常，例如：
try:
num = int("abc") # 会引发 ValueError 异常
result = 10 / 0 # 会引发 ZeroDivisionError 异常
except ValueError:
print("无法将字符串转换为整数")
except ZeroDivisionError:
print("除数不能为零")
捕获所有异常
也可以使用一个不带异常类型的 except 子句来捕获所有异常，但这种做法不推荐，因为它会隐藏一些可能是程序逻辑错误的异常，不利于调试。
try:
result = 10 / 0
except:
print("发生了异常")
else 子句
try – except 还可以搭配 else 子句使用，当 try 代码块中没有发生异常时，else 子句中的代码将被执行。
try:
num = 5
result = num + 3
except:
print("发生异常")
else:
print("没有异常发生，结果是:", result)
finally 子句
finally 子句无论是否发生异常都会被执行，通常用于释放资源等操作，如关闭文件、关闭数据库连接等。
try:
file = open('test.txt', 'r')
content = file.read()
except FileNotFoundError:
print("文件不存在")
finally:
if 'file' in locals():
file.close()
sorted()
在 Python 中，sorted()是一个内置函数，用于对可迭代对象进行排序，返回一个新的排好序的列表。其语法如下：
sorted(iterable, key=None, reverse=False)
参数说明
1. 对简单列表排序
nums = [5, 2, 8, 1, 9]
sorted_nums = sorted(nums)
print(sorted_nums)
输出：[1, 2, 5, 8, 9]
解释：直接对整数列表nums进行排序，默认按升序排列。
2. 按降序排序
nums = [5, 2, 8, 1, 9]
sorted_nums_desc = sorted(nums, reverse=True)
print(sorted_nums_desc)
输出：[9, 8, 5, 2, 1]
解释：通过设置reverse=True参数，使sorted函数对列表nums按降序排列。
3. 对字符串列表按字母顺序排序
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words)
print(sorted_words)
输出：['apple', 'banana', 'cherry', 'date']
解释：对字符串列表words按字母顺序进行升序排列。
4. 对字典列表按字典某个键的值排序
students = [
{"name": "Alice", "age": 20},
{"name": "Bob", "age": 18},
{"name": "Charlie", "age": 22}]
sorted_students = sorted(students, key=lambda x: x["age"])
print(sorted_students)
输出：[{'name': 'Bob', 'age': 18}, {'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 22}]
解释：通过key=lambda x: x["age"]指定按字典中"age"键对应的值对students列表进行排序。
5. 对二维列表按指定列排序
matrix = [
[3, 5],
[1, 7],
[2, 4]]
sorted_matrix = sorted(matrix, key=lambda x: x[1])
print(sorted_matrix)
输出：[[2, 4], [3, 5], [1, 7]]
解释：通过key=lambda x: x[1]指定按二维列表中每个子列表的第二个元素对matrix进行排序。
lambda函数
lambda是 Python 中的匿名函数，它允许快速定义一个简单的函数。其语法为：
lambda arguments: expression
其中：
1. 简单的数值计算
计算一个数的平方：
square = lambda x: x ** 2
result = square(5)
print(result)
输出：25
解释：lambda x: x ** 2定义了一个匿名函数，接受一个参数x，返回x的平方。
2. 字符串操作
将字符串转换为大写：
to_upper = lambda s: s.upper()
text = "hello"
result = to_upper(text)
print(result)
输出：HELLO
解释：该lambda函数接受一个字符串参数s，并返回其大写形式。
3. 列表排序
对包含元组的列表，按元组的第二个元素进行排序：
my_list = [(1, 5), (3, 2), (2, 8)]
sorted_list = sorted(my_list, key=lambda x: x[1])
print(sorted_list)
输出：[(3, 2), (1, 5), (2, 8)]
解释：key=lambda x: x[1]指定了sorted函数按照元组的第二个元素来排序。
4. 条件判断
判断一个数是否为偶数：
is_even = lambda num: num % 2 == 0
print(is_even(4))
print(is_even(5))
输出：
True
False
解释：lambda num: num % 2 == 0定义了一个函数，接受一个数num，判断它是否能被 2 整除，返回相应的布尔值。
5. 多个参数
计算两个数的和：
add = lambda a, b: a + b
result = add(3, 4)
print(result)
输出：7
解释：该lambda函数接受两个参数a和b，返回它们的和。
f-string（格式化字符串字面值）
基本用法
在字符串前加上 f 或 F 前缀，然后在字符串中使用大括号 {} 来嵌入 Python 表达式。表达式会在运行时被求值并替换到字符串中。
示例代码：
name = "Alice"
age = 25
print(f"我的名字是 {name}，我今年 {age} 岁了。")
输出结果：
我的名字是 Alice，我今年 25 岁了。
格式化数值
可以在大括号内的表达式后面使用冒号 : 来指定格式化说明符，对数值进行各种格式化操作。
整数格式化
指定宽度：使用数字指定输出的最小宽度，不足时默认用空格填充。
num = 42
print(f"数字是: {num:5}")
输出结果：
数字是: 42
这里指定宽度为 5，所以在 42 前面补了 3 个空格。
指定宽度并补零：在宽度前加上 0，表示用 0 填充不足的部分。
num = 42
print(f"数字是: {num:05}")
输出结果：
数字是: 00042
十六进制格式化：使用 x 或 X 将整数转换为十六进制，x 表示字母部分为小写，X 表示字母部分为大写。结合宽度和补零操作，可以实现类似 08X 的效果。
num = 255
print(f"十六进制小写: 0x{num:08x}")
print(f"十六进制大写: 0x{num:08X}")
输出结果：
十六进制小写: 0x000000ff
十六进制大写: 0x000000FF
浮点数格式化
指定小数位数：使用 .n 来指定保留的小数位数，n 为具体的数字。
pi = 3.1415926
print(f"π 保留两位小数: {pi:.2f}")
输出结果：
π 保留两位小数: 3.14
指定宽度和小数位数：可以同时指定宽度和小数位数。
num = 3.1415926
print(f"数字保留三位小数，宽度为 8: {num:8.3f}")
输出结果：
数字保留三位小数，宽度为 8: 3.142
格式化日期和时间
f-string 也可以用于格式化日期和时间对象。
import datetime
now = datetime.datetime.now()
print(f"当前日期和时间: {now:%Y-%m-%d %H:%M:%S}")
输出结果：
当前日期和时间: 2024-10-01 12:34:56 # 实际输出根据当前时间而定
这里 %Y 表示四位数的年份，%m 表示两位数的月份，%d 表示两位数的日期，%H 表示 24 小时制的小时，%M 表示分钟，%S 表示秒。
表达式嵌套
在 f-string 的大括号内可以使用更复杂的表达式，包括函数调用、属性访问等。
numbers = [1, 2, 3, 4, 5]
print(f"列表元素之和: {sum(numbers)}")
输出结果：
列表元素之和: 15
转义大括号
如果需要在 f-string 中显示大括号本身，可以使用双大括号 {{ 和 }}。
print(f"这是一个大括号: {{}}")
输出结果：
这是一个大括号: {}
进制转换
十进制转其他进制
1. 十进制转二进制
使用 bin() 函数可以将十进制整数转换为二进制字符串，该字符串以 0b 开头，表示这是一个二进制数。
decimal_num = 10
binary_num = bin(decimal_num)
print(binary_num) # 输出: 0b1010
2. 十进制转八进制
使用 oct() 函数可以将十进制整数转换为八进制字符串，该字符串以 0o 开头，表示这是一个八进制数。
decimal_num = 10
octal_num = oct(decimal_num)
print(octal_num) # 输出: 0o12
3. 十进制转十六进制
使用 hex() 函数可以将十进制整数转换为十六进制字符串，该字符串以 0x 开头，表示这是一个十六进制数。
decimal_num = 10
hexadecimal_num = hex(decimal_num)
print(hexadecimal_num) # 输出: 0xa
其他进制转十进制
使用 int() 函数可以将其他进制的字符串转换为十进制整数。int() 函数的第二个参数用于指定字符串的进制。
1. 二进制转十进制
binary_str = '0b1010'
decimal_num = int(binary_str, 2)
print(decimal_num) # 输出: 10
2. 八进制转十进制
octal_str = '0o12'
decimal_num = int(octal_str, 8)
print(decimal_num) # 输出: 10
3. 十六进制转十进制
hexadecimal_str = '0xa'
decimal_num = int(hexadecimal_str, 16)
print(decimal_num) # 输出: 10
自定义进制转换
def int_to_anybase(value, base):
if value == 0:
return 0
data = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
result = ''
while value != 0:
result = data[value % base] + result
value //= base
return result
def main():
value = int(input("请输入一个整数（代表值）："))
base = int(input("请输入一个整数（代表进制）："))
print(f"10进制{value}转换成{base}进制后的值是{int_to_anybase(value, base)}")
if __name__ == '__main__':
main()
格式化输出特定进制
除了上述函数，还可以使用字符串格式化方法来实现特定进制的输出，例如使用 f-string 或 str.format() 方法。
1. 使用 f-string
decimal_num = 10# 输出二进制
binary_str = f"{decimal_num:b}"
print(binary_str) # 输出: 1010
# 输出八进制
octal_str = f"{decimal_num:o}"
print(octal_str) # 输出: 12
# 输出十六进制（小写）
hexadecimal_str_lower = f"{decimal_num:x}"
print(hexadecimal_str_lower) # 输出: a
# 输出十六进制（大写）
hexadecimal_str_upper = f"{decimal_num:X}"
print(hexadecimal_str_upper) # 输出: A
2. 使用 str.format() 方法
decimal_num = 10# 输出二进制
binary_str = "{:b}".format(decimal_num)
print(binary_str) # 输出: 1010
# 输出八进制
octal_str = "{:o}".format(decimal_num)
print(octal_str) # 输出: 12
# 输出十六进制（小写）
hexadecimal_str_lower = "{:x}".format(decimal_num)
print(hexadecimal_str_lower) # 输出: a
# 输出十六进制（大写）
hexadecimal_str_upper = "{:X}".format(decimal_num)
print(hexadecimal_str_upper) # 输出: A
/=和//=的区别
在 Python 中，/=和//=是两个不同的复合赋值运算符，它们的区别如下：
运算规则
结果的数据类型
C++ 中的/=
先执行除法运算，再将结果赋值给左操作数。如果两个操作数都是整数，执行整数除法，会舍去小数部分；如果至少有一个操作数是浮点数，则执行浮点数除法。例如：int a = 10; a /= 3;，结果a的值为 3。若double b = 10.0; b /= 3;，则b的值约为 3.333333。
Python 中的//=
是地板除赋值运算符，它会对两个操作数进行地板除运算，即向下取整的除法运算，然后将结果赋值给左操作数。例如：a = 10; a //= 3，结果a的值为 3。即使操作数是浮点数，也是执行地板除，如b = 10.0; b //= 3，b的值为 3.0。
作者：掌上明居～
