python相关函数介绍（个人总结版）_python f用法-优快云博客

	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)
	# 输出: