目录
一、推导式：
Python 推导式是一种非常强大且简洁的构建数据结构的方法，它允许你使用一行代码来创建列表、字典、集合和生成器。推导式不仅代码量少，而且执行效率高，是 Python 编程中常用的特性之一。
（1）列表推导式
列表推导式用于创建列表，格式为：
[expression for item in iterable if condition]expression是对每个元素进行的操作。item是从iterable中依次取出的元素。iterable是一个序列。condition是一个可选的条件表达式。
示例代码：
# 创建一个包含0到9的列表，每个元素加3
numbers = [x + 3 for x in range(10)]
print(numbers) # 输出: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]（2）字典推导式：
字典推导式用于创建字典，格式为：
{key_expression: value_expression for item in iterable if condition}key_expression和value_expression分别是字典的键和值。item是从iterable中依次取出的元素。
示例代码：
# 创建一个字典，键是数字，值是数字的平方
squares = {x: x**2 for x in range(6)}
print(squares) # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}（3）集合推导式：
集合推导式用于创建集合，格式为：
{expression for item in iterable if condition}expression是对每个元素进行的操作。item是从iterable中依次取出的元素。
示例代码：
# 创建一个集合，包含0到9的数字
numbers_set = {x for x in range(10)}
print(numbers_set) # 输出: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}（4）生成器表达式：
生成器表达式用于创建生成器，格式为：
(expression for item in iterable if condition)expression是对每个元素进行的操作。item是从iterable中依次取出的元素。
示例代码：
# 创建一个生成器，生成0到9的数字
numbers_gen = (x for x in range(10))
print(list(numbers_gen)) # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]（5）总结：
推导式是 Python 中一种非常有用的语法结构，它允许以一种简洁和高效的方式创建和操作数据结构。列表、字典、集合和生成器推导式各有其用途，可以根据需要选择使用。使用推导式时，应注意保持代码的可读性，避免过度复杂的表达式。
二、 迭代器和生成器：
Python 中的迭代器和生成器是处理数据集合的强大工具，它们提供了一种高效的方式来访问和生成数据序列。
（1）迭代器（Iterator）：
- 迭代器是一个实现了迭代器协议的对象，即含有
__iter__()和__next__()方法的对象。迭代器从集合的第一个元素开始访问，直到所有元素被访问完毕。迭代器只能向前移动，不能后退。
（2）迭代器的创建：
- 通过内置的
iter()函数，可以将列表、元组、字典等可迭代对象转换成迭代器。 - 自定义类实现
__iter__()和__next__()方法，使其成为迭代器。
（3）示例代码：
class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index < len(self.data):
value = self.data[self.index]
self.index += 1
return value
else:
raise StopIteration
# 使用自定义迭代器
my_data = [1, 2, 3, 4, 5]
my_iter = MyIterator(my_data)
for value in my_iter:
print(value)（4）生成器（Generator）：
- 生成器是一种特殊的迭代器，它通过使用
yield语句来产生值。生成器允许你定义一个函数，该函数的行为类似于迭代器，但更加简洁和高效。
（5）生成器的优势：
- 节省内存：生成器在每次迭代时只产生一个值，而不是一次性生成整个数据集合。
- 易于编写：使用
yield语句可以轻松创建生成器。
（6）示例代码：
def my_generator():
for i in range(5):
yield i
# 使用生成器
gen = my_generator()
for value in gen:
print(value)（7）生成器表达式：
- 生成器表达式是列表推导式的一个变体，它使用圆括号而不是方括号，并返回一个生成器。
（8）示例代码：
# 生成器表达式
gen_expr = (x * 2 for x in range(5))
for value in gen_expr:
print(value)（9）总结：
- 迭代器和生成器是 Python 中处理序列数据的强大工具。迭代器提供了一种标准的方式来访问集合中的元素，而生成器则允许你以一种高效和内存友好的方式产生数据序列。生成器表达式进一步简化了生成器的创建过程，使得生成数据序列更加简洁。
三、 函数：
在Python中，函数是执行特定任务的代码块。你可以定义自己的函数，也可以使用Python提供的内建函数。下面将详细介绍Python函数的各个方面。
（1）定义函数：
- 在Python中，定义函数使用
def关键字，后跟函数名、括号（可能包含参数）和冒号。函数体必须缩进。
（2）基本语法：
def 函数名（参数列表）:
函数体
return [表达式]（3）示例代码：
def greet(name):
return f"Hello, {name}!"
print(greet("Alice")) # 输出: Hello, Alice!（4）参数：
函数参数允许你向函数传递数据。
- 必需参数：调用函数时必须提供的参数。
- 关键字参数：调用时可以按任意顺序提供，只要指定了参数名。
- 默认参数：在定义函数时指定默认值，如果调用时未提供，则使用默认值。
- 不定长参数：允许你传递任意数量的参数。
（5）示例代码：
def power(base, exponent=2):
return base ** exponent
print(power(3, 3)) # 输出: 27
print(power(3)) # 输出: 9，使用默认指数2（6）不定长参数：
使用星号(*)定义不定长参数。
*args：接收多个位置参数，作为元组。**kwargs：接收多个关键字参数，作为字典。
（7）示例代码：
def make_points(x, y, **kwargs):
print("x =", x)
print("y =", y)
for key, value in kwargs.items():
print(f"{key} = {value}")
make_points(1, 7, shape='circle', size=5)（8）匿名函数（Lambda函数）：
使用lambda关键字创建匿名函数，通常用于短暂的、不需要复用的小函数。
语法：
lambda 参数列表: 表达式参数：可以是一个或多个，多个参数间用逗号分隔。表达式：必须是一个表达式，不能包含语句。
特点：
- 匿名性：
lambda函数没有名称。 - 简洁性：适用于简单的函数定义，通常只有一行。
- 使用场景：常用于函数参数传递，如
map()、filter()、reduce()等。
示例代码：
sum = lambda x, y: x + y
print(sum(5, 3)) # 输出: 8返回值：
- 使用
return语句从函数返回一个值。如果没有return语句，函数默认返回None。
示例代码：
def add(a, b):
return a + b
result = add(5, 8)
print(result) # 输出: 13（9）参数传递
Python函数参数传递方式：
- 不可变类型（如整数、字符串、元组）：按值传递。函数内修改参数不会影响原始数据。
- 可变类型（如列表、字典）：按引用传递。函数内修改参数会影响原始数据。
示例代码：
def modify_list(input_list):
input_list.append(3)
my_list = [1, 2]
modify_list(my_list)
print(my_list) # 输出: [1, 2, 3]（10）强制位置参数：
Python 3.8引入了一种新的语法，允许指定某些参数必须以位置方式传递。
示例代码：
def func(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
func(1, 2, 3, d=4, e=5, f=6) # 正确
# func(1, b=2, c=3, d=4, e=5, f=6) # 错误：b必须位置传递（11）总结：
- 函数是Python中实现代码复用和模块化的关键工具。通过定义函数，你可以创建可重用的代码块来执行特定任务。函数可以接受参数，可以有返回值，并且可以以多种方式处理参数。
四、装饰器：
装饰器是Python中一个非常有用的特性，它允许在不修改原有函数代码的情况下，给函数增加新的功能。装饰器本质上是一个Python函数，它可以让其他函数增值。
（1）装饰器的基本用法：
定义一个装饰器：
def my_decorator(func):
def wrapper(*args, **kwargs):
# 在被装饰函数执行前的代码
result = func(*args, **kwargs)
# 在被装饰函数执行后的代码
return result
return wrapper使用装饰器：
@my_decorator
def say_hello():
print("Hello!")
say_hello() # 执行后会打印 "Hello!"等价于：
def say_hello():
print("Hello!")
say_hello = my_decorator(say_hello)（2）带参数的装饰器：
有时候，你可能需要创建一个装饰器，它本身也接受参数。为此，你可以定义一个返回装饰器的函数。
def repeat(num_times):
def decorator_repeat(func):
def wrapper(*args, **kwargs):
for _ in range(num_times):
value = func(*args, **kwargs)
return value
return wrapper
return decorator_repeat
@repeat(num_times=3)
def greet(name):
print(f"Hello, {name}")
greet("World") # 打印三次 "Hello, World"（3）类装饰器：
类装饰器是另一种定义装饰器的方法，它通过定义一个类，在类中实现__call__方法。
class MyDecorator:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
# 执行前的代码
result = self.func(*args, **kwargs)
# 执行后的代码
return result
@MyDecorator
def say_hello():
print("Hello!")
say_hello() # 执行后会打印 "Hello!"（4）装饰器的应用场景：
- 日志记录：在函数执行前后打印日志信息。
- 性能测试：测量函数执行时间。
- 事务处理：在函数执行前后进行事务的提交或回滚。
- 缓存：缓存函数的执行结果以提高效率。
- 权限控制：检查用户是否有权执行函数。
（5）示例：简单的日志记录装饰器：
import functools
def log_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
result = func(*args, **kwargs)
print(f"{func.__name__} returned {result}")
return result
return wrapper
@log_decorator
def add(a, b):
return a + b
add(2, 3) # 会打印关于函数调用和返回的日志信息- 使用装饰器时，
functools.wraps用于保留原函数的元信息，如函数名和文档字符串。
五、数据结构：
在Python中，数据结构是组织和存储数据的方式，以便可以高效地进行访问和修改。Python提供了多种内置数据结构，包括列表、元组、集合和字典。
（1）列表（List）：
- 列表是Python中使用最广泛的数据结构之一，它是一个有序的集合，可以包含任意类型的对象，并且可以修改。
列表的方法：
append(x): 在列表末尾添加一个元素。extend(L): 将一个列表的所有元素添加到另一个列表末尾。insert(i, x): 在指定位置插入一个元素。remove(x): 移除列表中第一个值为x的元素。pop([i]): 移除列表中指定位置的元素，并返回该元素。clear(): 清空列表。index(x): 返回列表中第一个值为x的元素的索引。count(x): 返回x在列表中出现的次数。sort(): 对列表进行排序。reverse(): 反转列表。
示例代码：
a = [66.25, 333, 333, 1, 1234.5]
a.append(333) # [66.25, 333, 333, 1, 1234.5, 333]
a.insert(2, -1) # [66.25, 333, -1, 333, 1, 1234.5, 333]
a.remove(333) # [66.25, -1, 333, 1, 1234.5, 333]
print(a.index(333)) # 输出: 2
a.sort() # [-1, 1, 333, 333, 66.25, 1234.5]（2）元组（Tuple）：
元组与列表类似，但它是不可变的，这意味着一旦创建就不能修改。
示例代码：
t = (12345, 54321, 'hello!')
print(t[0]) # 输出: 12345
t = 1, 2, 3 # 创建元组
print(t) # 输出: (1, 2, 3)（3）集合（Set）：
集合是一个无序的不重复元素集，可以进行数学上的集合运算，如并集、交集、差集等。
示例代码：
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) # 输出: {'orange', 'banana', 'pear', 'apple'}
print('orange' in basket) # 输出: True
a = set('abracadabra')
b = set('alacazam')
print(a - b) # {'r', 'd', 'b'} 在a中但不在b中（4）字典（Dictionary）：
字典是存储键值对的数据结构，其中的键必须是不可变类型，如字符串或数字。
示例代码：
tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127 # 添加新的键值对
print(tel['jack']) # 输出: 4098
del tel['sape'] # 删除键'sape'
print(tel) # 输出: {'jack': 4098, 'guido': 4127}（5）列表推导式（List Comprehension）：
列表推导式提供了一种简洁的方法来创建列表，通常用于从序列或其它可迭代对象中生成新的列表。
示例代码：
vec = [2, 4, 6]
print([3*x for x in vec]) # 输出: [6, 12, 18]（6）del语句：
del语句用于删除对象，可以删除列表的切片或整个列表，也可以删除字典的条目或整个字典，以及删除变量。
示例代码：
a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0] # 删除第一个元素
print(a) # 输出: [1, 66.25, 333, 333, 1234.5]
del a[:] # 清空列表
print(a) # 输出: []（7）遍历技巧：
Python提供了多种遍历序列的方法，包括items()、enumerate()、zip()和reversed()。
示例代码：
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
print(k, v) # 输出: gallahad the pure, robin the brave
for i, v in enumerate(['tic', 'tac', 'toe']):
print(i, v) # 输出: 0 tic, 1 tac, 2 toe
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print('What is your {0}? It is {1}.'.format(q, a))六、模块 ：
Python中的模块是一种包含Python定义和声明的文件。模块可以定义函数、类和变量，也可以包含可执行的代码。
（1）模块的概念：
- 模块：一个
.py文件就是一个模块，模块可以被导入到其他Python文件中使用。 - 包：包是包含多个模块的容器，通常用于组织大型项目。
（2）导入模块：
- 使用
import语句可以将模块导入到Python文件中。
示例代码：
# 导入sys模块
import sys
# 打印命令行参数
print('命令行参数如下:')
for i in sys.argv:
print(i)
# 打印Python搜索模块的路径
print('\nPython 路径为：', sys.path)（3）模块的搜索路径：
- Python解释器在一系列目录中搜索模块，这些目录的列表存储在
sys.path中。
示例代码：
import sys
print(sys.path)（4）模块的导入机制：
- 当使用
import语句时，Python会在sys.path中搜索模块文件。
（5）模块的命名空间：
- 每个模块被导入时，其内部的变量和函数都会被添加到一个命名空间中。
（6）__name__属性：
- 每个模块都有一个
__name__属性，当模块被直接运行时，__name__的值为'__main__'。
示例代码：
# 判断模块是被导入还是被直接运行
if __name__ == '__main__':
print('模块被直接运行')
else:
print('模块被导入')（7）dir()函数：
dir()函数不带参数时，返回当前模块（在交互式解释器中是__main__）中定义的所有名称的列表。
示例代码：
a = [1, 2, 3]
import sys
print(dir())（8）包的概念：
- 包是包含多个模块的容器，通常用于组织大型项目。
（9）包的结构：
- 包通常包含一个
__init__.py文件，用于初始化包。
示例包结构
sound/
__init__.py
formats/
__init__.py
wavread.py
wavwrite.py
...
effects/
__init__.py
echo.py
surround.py
...（10）导入包中的模块：
- 可以使用
from package import module语法从包中导入模块。
示例代码：
from sound.effects import echo
echo.echofilter(input, output, delay=0.7, atten=4)（11）相对导入：
- 在包内部，可以使用相对导入来导入同一包内的其他模块。
示例代码：
# 在sound.effects模块中
from . import echo
from .. import formats
from ..filters import equalizer（12）__all__列表：
- 在包的
__init__.py文件中定义__all__列表，可以控制from package import *时导入的模块。
示例代码：
# 在sound/effects/__init__.py中
__all__ = ["echo", "surround", "reverse"]（13）包的__path__属性：
__path__属性是一个列表，包含了包中所有子包和模块的路径。
（14）标准库和第三方库：
- Python标准库是与Python一起发布的模块集合，第三方库是其他开发者提供的模块集合。
（15）总结：
- 模块和包是Python中组织代码的重要方式，通过合理地使用模块和包，可以有效地组织和管理大型项目。导入机制使得代码的复用变得简单，而
__name__属性和dir()函数则为模块的运行和调试提供了便利。包的概念则进一步扩展了模块的组织能力，使得大型项目的管理更加有序。
七、输入和输出：
Python的输入输出是编程中常见的操作，涉及到数据的读取和写入。
（1）输出数据：
表达式语句：
直接在Python代码中写出变量或表达式，Python解释器会自动将其转换为字符串并打印出来。这种方式简单但功能有限，因为它不支持格式化。
示例代码：
x = 10
y = 20
print(x + y) # 输出表达式的结果（2）print() 函数：
print() 是Python中用于输出的主要函数，它支持多种格式化选项，可以同时打印多个值，并控制输出格式。
格式化输出：
- 字符串拼接：使用
+操作符将多个字符串拼接在一起。 str.format()：提供了一种更灵活的方式来格式化字符串。repr()和str()：repr()用于获取对象的“官方”字符串表示，通常用于调试；str()用于获取对象的“非官方”字符串表示，更易于阅读。
示例代码：
x = 10
y = 20
print("The sum of x and y is: " + str(x + y)) # 使用str()转换数字为字符串
name = "Alice"
print("Hello, {}".format(name)) # 使用format方法
print("Hello, {0}! Your balance is {1:.2f}".format(name, 123.4567)) # 格式化输出（3）文件的 write() 方法：
可以通过文件对象的write()方法将数据写入文件。这对于生成日志文件或处理大量数据时非常有用。
示例代码：
with open('output.txt', 'w') as f:
f.write("Hello, file!\n")（4）输入数据：
input() 函数：
input() 函数用于从用户那里接收输入。它读取用户输入的字符串，并将其作为字符串返回。
示例代码：
user_input = input("Please enter your name: ")
print("Hello, " + user_input)（5）文件读写：
在Python中，open() 函数是用来打开文件的，它的第一个参数是文件名，第二个参数是模式。不同的模式影响文件的打开方式和文件指针的位置。
r：以只读方式打开文件。文件必须存在，否则会抛出FileNotFoundError。文件指针放在文件开头。
f = open('example.txt', 'r')
content = f.read()
print(content)
f.close()rb：以二进制格式打开一个文件用于只读。这在读取非文本文件（如图片、视频等）时非常有用。文件指针同样放在文件开头。
f = open('image.png', 'rb')
data = f.read()
f.close()r+：打开一个文件用于读写。如果文件不存在，会抛出FileNotFoundError。文件指针放在文件开头。
f = open('example.txt', 'r+')
f.write('New content')
f.close()rb+：以二进制格式打开一个文件用于读写。文件指针放在文件开头。
f = open('data.bin', 'rb+')
f.write(b'\x00\x01\x02')
f.close()w：打开一个文件只用于写入。如果文件存在，会截断文件（即删除文件内容），如果文件不存在，会创建新文件。文件指针放在文件开头。
f = open('newfile.txt', 'w')
f.write('Hello, world!')
f.close()wb：以二进制格式打开一个文件只用于写入。如果文件存在，也会截断文件。
f = open('newimage.png', 'wb')
f.write(b'\x00\x01\x02')
f.close()w+：打开一个文件用于读写。如果文件存在，会截断文件；如果文件不存在，会创建新文件。文件指针放在文件开头。
f = open('rwfile.txt', 'w+')
f.read() # 读取内容（此时文件为空，所以返回空字符串）
f.close()wb+：以二进制格式打开一个文件用于读写。如果文件存在，会截断文件。
f = open('rwbin.dat', 'wb+')
f.read() # 读取内容
f.close()a：打开一个文件用于追加。如果文件存在，文件指针将会放在文件的结尾，即新写入的数据会追加到文件末尾。如果文件不存在，会创建新文件。这种方式不能读取文件。
f = open('appendfile.txt', 'a')
f.write('Appended text\n')
f.close()ab：以二进制格式打开一个文件用于追加。如果文件存在，文件指针将会放在文件的结尾。
f = open('appendbin.dat', 'ab')
f.write(b'\x04\x05\x06')
f.close()a+：打开一个文件用于读写。如果文件存在，文件指针将会放在文件的结尾，但文件打开时会是追加模式，即写入的数据会追加到文件末尾。如果文件不存在，会创建新文件。
f = open('readwritefile.txt', 'a+')
f.write('More text\n')
f.seek(0) # 移动文件指针到文件开头，以便读取
print(f.read())
f.close()ab+：以二进制格式打开一个文件用于读写。如果文件存在，文件指针将会放在文件的结尾。
f = open('readwritebin.dat', 'ab+')
f.write(b'\x07\x08\x09')
f.seek(0)
print(f.read())
f.close()- 在处理文件时，通常建议使用
with语句来自动管理文件的打开和关闭，即使在发生异常时也能保证文件正确关闭。 - 可以使用
read()、readline()或readlines()方法从文件中读取数据。
（6）写入文件：
使用write()方法将数据写入文件。
示例代码：
with open('example.txt', 'w') as f:
f.write("Hello, world!\n")（7）pickle 模块：
pickle模块在Python中用于序列化和反序列化对象。序列化是将对象的状态信息转换为可以存储或传输的格式的过程。反序列化是将序列化的数据转回为Python对象的过程。
基本用法：
pickle.dump(obj, file)：将对象obj序列化并写入到文件对象file。pickle.load(file)：从文件对象file中读取数据并反序列化成Python对象。
示例代码：
import pickle
data = {'key': 'value', 'list': [1, 2, 3]}
# 序列化并保存到文件
with open('data.pkl', 'wb') as f:
pickle.dump(data, f)
# 从文件中反序列化
with open('data.pkl', 'rb') as f:
loaded_data = pickle.load(f)
print(loaded_data)八、文件操作方法：
在Python中，文件操作是一项基本而重要的任务。open() 函数是进行文件操作的起点，它用于打开文件并返回一个文件对象，通过这个文件对象可以进行读写操作。
（1）open() 函数：
open()函数用于打开一个文件，并返回一个文件对象。如果不手动关闭文件，Python的垃圾回收机制会在文件不再使用时自动关闭它，但最佳实践是明确地关闭文件。
语法：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)参数：
file: 文件路径，可以是相对路径或绝对路径。mode: 文件打开模式，如'r'、'w'、'b'等。buffering: 缓冲区大小，通常为-1（系统默认）。encoding: 指定文件的编码，如'utf-8'。errors: 指定如何处理编码错误。newline: 控制换行符。closefd: 用于控制是否关闭文件描述符。opener: 用于打开文件的自定义函数。
模式：
'r': 只读（默认）'w': 写入（覆盖）'b': 二进制模式'+': 更新（读写）'x': 独占创建，文件必须不存在。'a': 追加，写入数据会追加到文件末尾。
（2）文件对象的方法：
文件对象提供了多种方法来操作文件内容。
-
close()：关闭文件并释放系统资源。f = open('example.txt', 'r') f.close() -
flush()：刷新文件缓冲区，确保所有缓冲的数据都写入文件。f = open('example.txt', 'w') f.write('Hello, world!') f.flush() # 确保数据写入 -
read([size])：读取指定数量的字符，如果未指定或为负，则读取整个文件。f = open('example.txt', 'r') content = f.read() print(content) -
readline([size])：读取一行，包括行尾的换行符。f = open('example.txt', 'r') line = f.readline() print(line) -
readlines([sizehint])：读取所有行，并返回一个列表。f = open('example.txt', 'r') lines = f.readlines() for line in lines: print(line.strip()) # strip() 去除换行符 -
seek(offset[, whence])：移动文件指针到指定位置。f = open('example.txt', 'r') f.seek(0) # 移动到文件开头 -
tell()：返回当前文件指针的位置。f = open('example.txt', 'r') print(f.tell()) # 打印当前位置 -
write(string)：写入字符串到文件。f = open('example.txt', 'w') f.write('Hello, world!') -
writelines(sequence)：写入字符串序列，需要自行添加换行符。f = open('example.txt', 'w') lines = ['First line', 'Second line'] f.writelines(lines) -
truncate([size])：截断文件，删除指定位置后的所有内容。f = open('example.txt', 'r+') f.truncate() # 从当前位置截断文件
（3）使用 with 语句管理文件：
使用with语句可以自动管理文件的打开和关闭，即使在发生异常时也能保证文件正确关闭。
with open('example.txt', 'w') as f:
f.write('Hello, world!')
# 文件在with块结束时自动关闭（4）文件读写操作示例：
使用open()函数和文件对象的方法进行文件读写操作。
# 写入文件
with open('example.txt', 'w') as f:
f.write('Hello, world!\n')
f.write('This is another line.\n')
# 读取文件
with open('example.txt', 'r') as f:
content = f.read()
print(content)
# 逐行读取文件
with open('example.txt', 'r') as f:
for line in f:
print(line.strip())
# 追加内容到文件
with open('example.txt', 'a') as f:
f.write('Appending new line.\n')
# 读取并修改文件内容
with open('example.txt', 'r+') as f:
content = f.read()
f.seek(0) # 移动到文件开头
f.write(content.replace('world', 'Python'))
扫一扫
1064
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
