渗透测试---python基础：基础语法的使用

声明：学习素材来自b站up【泷羽Sec】，侵删，若阅读过程中有相关方面的不足，还请指正，本文只做相关技术分享,切莫从事违法等相关行为，本人一律不承担一切后果

目录

一、简介：什么是python?

二、python安装与共存

三、pip介绍

 pip的优势

四、基本数据类型

Python3 中常见的数据类型有：

Number（数字）

String（字符串）

布尔类型 (Boolean Type)

List（列表）

Tuple(元组)

Dictionary(字典)

五、条件控制（if，elif）

语法：

六、循环语句

while

for...else

break 和 continue 语句及循环中的 else 子句

七、函数

1. 默认参数

2. 可变参数

3. 高阶函数

4. 函数文档字符串（Docstring）

5. 装饰器

6. 函数缓存 (Memoization)

7. 闭包

8. 类型注解

9. Lambda 函数

10. 生成器函数

八、 迭代器和生成器

迭代器

生成器

九、lambda表达式

十、异常处理

else 子句

自定义上下文管理器

重新引发异常

自定义异常

1. BaseException

2. Exception

3. ArithmeticError

4. LookupError

5. TypeError

6. ValueError

7. FileNotFoundError

8. IOError

9. OSError

10. ImportError

11. NameError

12. AttributeError

13. IndexError

14. KeyError

15. StopIteration

16. RuntimeError

17. SyntaxError

18. IndentationError

19. AssertionError

20. UnicodeError

21. MemoryError

十一、文件操作

读取

写入

高级用法：

使用上下文管理器 (with 语句)

 读取大文件的分块处理

文件读取模式

文件位置操作

使用 pathlib 进行文件路径操作

文件内容的写入模式

使用 csv 模块处理 CSV 文件

使用 json 模块处理 JSON 文件

文件压缩和解压缩

文件系统操作

一、简介：什么是python?

Python 是一个 解释性、编译性、互动性和面向对象 的脚本语言。

Python 的设计具有很强的可读性，相比其他语言更容易学习。

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。

Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。

Python 是面向对象语言 : 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。

Python 是初学者的语言： Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

1. 易于学习： Python 有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。

2. 易于阅读： Python 代码定义的更清晰。

3. 易于维护： Python 的成功在于它的源代码是相当容易维护的。

4. 一个广泛的标准库： Python 的最大的优势之一是丰富的库，跨平台的，在 UNIX ， Windows 和

Macintosh 兼容很好。

5. 互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代

码片断。

6. 可移植：基于其开放源代码的特性， Python 已经被移植（也就是使其工作）到许多平台。

7. 可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用

C 或 C++ 完成那部分程序，然后从你的 Python 程序中调用。

8. 数据库： Python 提供所有主要的商业数据库的接口。

9. GUI 编程： Python 支持 GUI 可以创建和移植到许多系统调用。

10. 可嵌入 : 你可以将 Python 嵌入到 C/C++ 程序，让你的程序的用户获得 " 脚本化 " 的能力。

三、pip介绍

 pip的优势

• 自动解决依赖关系：pip在安装包时会自动解析和安装包的依赖项，避免了手动安装依赖的麻烦。
• 版本控制：pip可以轻松地管理不同版本的Python包，根据需要安装、更新或卸载特定版本的包。
• 跨平台支持：pip可以在不同的操作系统和Python环境中使用，具有很好的跨平台支持能力。
• 社区支持：pip拥有庞大的用户群体和活跃的社区，这意味着在使用过程中遇到问题时可以快速找到解决方案或者得到社区的帮助。

pip 功能

查看 pip 版本

pip --version
pip -V

安装 python 包，例如

pip install shodan

卸载 python 包

pip uninstall shodan

批量导出系统依赖

这个命令会将当前环境中所有已安装的包及其版本信息导出到requirements.txt文件中
pip freeze > requirements.txt

批量安装库 requirements.txt

pip install -r requirements.txt

列出所有已经安装的包

pip list

查看某个包的信息

pip show package_name

更新指定的包

pip install --upgrade package_name

指定下载源:以阿里、清华镜像源为例

pip install -i https://mirrors.aliyun.com/pypi/simple

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple some-package

四、基本数据类型

Python3 中常见的数据类型有：

• Number（数字）
• String（字符串）：制表符，换行符，切片，
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Number（数字）

Python3 支持 int、float、bool、complex（复数） 。

在 Python 3 里，只有一种整数类型 int ，表示为长整型，没有 python2 中的 Long 。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

String（字符串）

字符串 (str): 用于表示文本，例如 "Hello, World!"。字符串可以用单引号或双引号定义

Python 中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

字符串的截取的语法格式如下：

#!/usr/bin/python3
str = 'SFeather' # 定义一个字符串变量
print(str) # 打印整个字符串
print(str[0:-1]) # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0]) # 打印字符串的第一个字符
print(str[2:5]) # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:]) # 打印字符串从第三个字符开始到末尾
print(str * 2) # 打印字符串两次
print(str + "TEST") # 打印字符串和"TEST"拼接在一起
str[1]='小羽' # 修改指定的字符
print(str)

Python 使用反斜杠 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个r  ，表示原始字符串：

>>> print('SF\neather')
SF
eather
>>> print(r'SF\neather')
SF\neather

布尔类型 (Boolean Type)

布尔值 (bool): 只有两个值，True（真）和 False（假）。

布尔类型有两种，即 true 和 false ，类似与正确和错误

a=True
b=False
print("变量a的内容是{a},\t类型是{type(a)}")
print("变量b的内容是{b},\t类型是{type(b)}"

List（列表）

List （列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串 甚至可以包含列表（所谓嵌套）。列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

1. 索引值以 0 为开始值， -1 为从末尾的开始位置。

2. 加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：

#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'SFeather', 70.2 ] # 定义一个列表
tinylist = [123, 'SFeather']
print (list) # 打印整个列表
print (list[0]) # 打印列表的第一个元素
print (list[1:3]) # 打印列表第二到第四个元素（不包含第四个元素）
print (list[2:]) # 打印列表从第三个元素开始到末尾
print (tinylist * 2) # 打印tinylist列表两次
print (list + tinylist) # 打印两个列表拼接在一起的结果

['abcd', 786, 2.23, 'SFeather', 70.2]
abcd
[786, 2.23]
[2.23, 'SFeather', 70.2]
[123, 'SFeather', 123, 'SFeather']
['abcd', 786, 2.23, 'SFeather', 70.2, 123, 'SFeather']

List 内置了有很多方法，例如 append() 、 pop() 等等

列表推导式

tuple=['name', 'age', 'address']
list1=[x for x in tuple]
list2=[x for x in range(20)]
print(list1)
print(list2)

['name', 'age', 'address']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

常用命令

append(x)：追加到链尾。
extend(L)：追加一个列表，等价于+=。
insert(i,x)：在位置i插入x，其余元素向后推，如果i大于列表长度，就在最后添加，如果i小于0，就在最
开始添加。
remove(x)：删除第一个值为x的元素，如果不存在会抛出异常。
reverse()：反转序列。
pop([i])：返回并删除位置为i的元素，i默认为最后一个元素。
index(x)：返回x在列表中第一次出现的位置，不存在则抛出异常。
count(x)：返回x出现的次数。
sort()：排序。
len(List)：返回List的长度。
del list[i]：删除列表list中指定的第i + 1个变量。

Tuple(元组)

元组（ tuple ）与列表类似，不同之处在于 元组的元素不能修改 。元组写在小括号 () 里，元素之间用逗号隔开

元组推导式

tuple=('name', 'age', 'address')
x={x for x in tuple}
print(x)

{'name', 'address', 'age'}

Dictionary(字典)

字典（ dictionary ）是 Python 中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键 来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键 (key) 必须使用不可变类型。

在同一个字典中，键 (key) 必须是唯一的。

dict = {}
dict['one'] = "1 "
dict[2] = "2 "
tinydict = {'name': '小羽老师','code':1, 'site': 'sec.54cto.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值

1 
2 
{'name': '小羽老师', 'code': 1, 'site': 'sec.54cto.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['小羽老师', 1, 'sec.54cto.com'])

字典推导式

num=99
x={x: index*num for index,x in enumerate(['key1', 'key2', 'key3'])}
print(x)

{'key1': 0, 'key2': 99, 'key3': 198}

五、条件控制（if，elif）

语法：

if condition1:  
    # 当condition1为真时执行的代码  
elif condition2:  
    # 当condition1为假且condition2为真时执行的代码  
else:  
    # 当condition1和condition2都为假时执行的代码

eg：

number = 10  

if number > 0:  
    print("这个数字是正数。")  
elif number < 0:  
    print("这个数字是负数。")  
else:  
    print("这个数字是零。")

六、循环语句

while

else联用

count = 0  
while count < 5:  
    print(count)  
    count += 1  
else:  
    print("循环正常结束，没有使用break。")

无限循环

while True:  
    user_input = input("请输入一个数字（输入'quit'退出）：")  
    if user_input.lower() == 'quit':  
        break  
    print(f"你输入的数字是：{user_input}")

continue联用

count = 0  
while count < 10:  
    count += 1  
    if count == 5:  
        continue  # 跳过输出5  
    print(count)

嵌套while

i = 0  
while i < 3:  
    j = 0  
    while j < 3:  
        print(f"i={i}, j={j}")  
        j += 1  
    i += 1

条件语句联用

def is_even(num):  
    return num % 2 == 0  

num = 0  
while is_even(num) or num < 10:  
    print(num)  
    num += 1

使用计数器与列表

numbers = [1, 2, 3, 4, 5]  
index = 0  
while index < len(numbers):  
    print(numbers[index])  
    index += 1

无限读取用户输入

responses = []  
while True:  
    response = input("输入你的回答（或输入'退出'结束）：")  
    if response.lower() == '退出':  
        break  
    responses.append(response)  

print("你的回答列表：", responses)

for...else

在 Python 中， for...else 语句用于在循环结束后执行一段代码。

语法格式如下：

for item in iterable:
循环主体
else:
# 循环结束后执行的代码

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程 中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

for x in range(6):
print(x)
else:
print("程序结束!")

输出

0
1
2
3
4
5
程序结束!

break 和 continue 语句及循环中的 else 子句

while 中的 break

while 中使用 continue

pass 语句

1. Python pass是空语句，是为了保持程序结构的完整性。

2. pass 不做任何事情，一般用做占位语句，如下实例

while
pass
for
pass
class
pass
def
pass

七、函数

函数声明

函数调用

递归调用

参数传递

1. 默认参数

可以为函数的参数定义默认值，这样在调用时可以选择性地省略某些参数。

def greet(name, message="你好"): 
print(f"{message}, {name}") 
greet("Alice") # 使用默认消息 
greet("Bob", "欢迎") # 提供自定义消息

2. 可变参数

使用*args和**kwargs来接受不定数量的参数。

def print_args(*args): 
for arg in args:
 print(arg) print_args(1, 2, 3) # 接受位置参数 
def print_kwargs(**kwargs):
 for key, value in kwargs.items():
 print(f"{key}: {value}") 
print_kwargs(name="Alice", age=30) # 接受关键字参数

3. 高阶函数

函数可以作为参数传递给其他函数，也可以返回函数。

def apply_function(func, value):
 return func(value)
def square(x):
  return x * x 
result = apply_function(square, 5) # 传入函数和参数 
print(result)

4. 函数文档字符串（Docstring）

为函数添加文档字符串，可以用于描述函数的功能，参数和返回值。

def add(a, b):
 """返回两个数字的和。
 参数: a (int): 第一个数字
       b (int): 第二个数字 
返回: 
int: 两个数字的和
 """ 
return a + b 
print(add.__doc__) # 打印文档字符串

5. 装饰器

装饰器是一种在不修改函数代码的情况下，动态增加功能的方式。

def decorator(func):  
    def wrapper(*args, **kwargs):  
        print("调用函数之前")  
        result = func(*args, **kwargs)  
        print("调用函数之后")  
        return result  
    return wrapper  

@decorator  
def say_hello(name):  
    print(f"你好，{name}")  

say_hello("Alice")

6. 函数缓存 (Memoization)

使用functools.lru_cache，可以缓存函数的返回值以提高性能。

from functools import lru_cache  

@lru_cache(maxsize=None)  
def fibonacci(n):  
    if n < 2:  
        return n  
    return fibonacci(n - 1) + fibonacci(n - 2)  

print(fibonacci(10))  # 之前的计算将被缓存

7. 闭包

def make_multiplier(factor):  
    def multiply(x):  
        return x * factor  
    return multiply  

double = make_multiplier(2)  
print(double(5))  # 输出 10

8. 类型注解

使用类型注解为函数参数和返回值指定类型，这可以提高代码可读性，并支持类型检查工具。

def add(a: int, b: int) -> int:  
    return a + b  

print(add(2, 3))  # 输出 5

9. Lambda 函数

使用 lambda 表达式定义小型匿名函数。

add = lambda x, y: x + y  
print(add(2, 3))  # 输出 5  

# 在高阶函数中使用  
numbers = [1, 2, 3, 4]  
squared = list(map(lambda x: x ** 2, numbers))  
print(squared)  # 输出 [1, 4, 9, 16]

10. 生成器函数

使用 yield 关键字定义生成器函数，可以迭代返回值。

def count_up_to(max):  
    count = 1  
    while count <= max:  
        yield count  
        count += 1  

for number in count_up_to(5):  
    print(number)  # 输出 1, 2, 3, 4, 5

八、 迭代器和生成器

迭代器

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后

退。

迭代器有两个基本的方法： iter() 和 next() 。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list) # 创建迭代器对象
>>> print (next(it)) # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规 for 语句进行遍历：

#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")

也可以使用 next() 函数：

#!/usr/bin/python3
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:
sys.exit()

生成器

1. 它可以在循环中逐个返回值，而不必将所有值一次性加载到内存中。生成器函数使用 yield 关键字

来暂停函数执行并产生一个值，然后在需要下一个值时再次恢复执行。这使得生成器在处理大量数

据或无限序列时非常高效。

2. 生成器函数看起来像一个普通函数，但使用 yield 而不是 return 返回结果。每次调用生成器函数

时，它都会在上次离开的位置继续执行。

def simple_generator():
yield 1
yield 2
yield 3
gen = simple_generator()
for value in gen:
print(value)

1
2
3

斐波那契数列生成器：F(n)=F(n 1)+F(n-2)

def fibonacci_generator(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
使用生成器
n = 10
fib_gen = fibonacci_generator(n)
for num in fib_gen:
print(num)

九、lambda表达式

 lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如 在 map()、filter()、reduce() 等函数中。

f = lambda: "Hello, world!"
print(f()) # 输出: Hello, world!

以下实例使用 lambda 创建匿名函数，设置一个函数参数 a，函数计算参数 a 加 10，并返回结果：

x = lambda a : a + 10
print(x(5))

以下实例使用 lambda 创建匿名函数，函数参数 a、b 与 c 相加，并返回结果：

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

lambda 函数通常与内置函数如 map() 、 filter() 和 reduce() 一起使用，以便在集合上执行操作。例如：

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]

十、异常处理

 异常捕捉可以使用 try/except 语句。

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系

统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

while True:
try:
x = int(input("请输入一个数字: "))
break
except ValueError:
print("您输入的不是数字，请再次尝试输入！")

try 语句按照如下方式工作；

首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。

如果没有异常发生，忽略 except 子句， try 子句执行后结束。

如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和

except 之后的名称相符，那么对应的 except 子句将被执行。

如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。

一个 try 语句可能包含多个 except 子句，分别来处理不同的特定的异常。最多只有一个分支会被执

行。

处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

else 子句

在 try 块没有引发异常的情况下执行 else 子句，适用于需要在代码正常执行的情况下执行的代码。

try:  
    result = 10 / 2  
except ZeroDivisionError:  
    print("除以零!")  
else:  
    print(f"结果是: {result}")

一个except子句可以同时处理多个异常 ，这些异常将被放在一个括号里成为一个元组，例如 :

except (RuntimeError, TypeError, NameError):
pass

try:  
    # 可能引发多个异常的代码  
    result = 10 / int(input("请输入一个整数: "))  
except (ValueError, ZeroDivisionError) as e:  
    print(f"发生了异常: {e}")

try-finally

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
runoob()
except AssertionError as error:
print(error)
else:
try:
with open('file.log') as file:
read_data = file.read()
except FileNotFoundError as fnf_error:
print(fnf_error)
finally:
print('这句话，无论异常是否发生都会执行。')

file = None  
try:  
    file = open("example.txt", "r")  
    content = file.read()  
except FileNotFoundError:  
    print("文件未找到!")  
finally:  
    if file:  
        file.close()

自定义上下文管理器

可以使用 __enter__ 和 __exit__ 方法创建自定义上下文管理器，以处理特定的异常情况。

class MyContext:  
    def __enter__(self):  
        print("进入上下文")  
        return self  

    def __exit__(self, exc_type, exc_value, traceback):  
        if exc_type:  
            print(f"发生异常: {exc_value}")  
        print("退出上下文")  

with MyContext():  
    raise ValueError("测试异常")

重新引发异常

在 except 块中，可以使用 raise 语句重新引发当前异常，以便 сохранить стеки вызовов:

try:  
    1 / 0  
except ZeroDivisionError as e:  
    print("捕获到 ZeroDivisionError，正在重新抛出")  
    raise  # 重新引发异常

自定义异常

你可以定义自己的异常类，从 Exception 继承，以便在特定情况下抛出和捕获。

class MyCustomError(Exception):  
    pass  

def risky_function():  
    raise MyCustomError("自定义异常发生了")  

try:  
    risky_function()  
except MyCustomError as e:  
    print(f"捕获到自定义异常: {e}")

异常类型、

1. BaseException

所有异常的基类，通常不直接被用户代码捕获。

2. Exception

所有普通异常的基类，用户自定义的异常也应该继承自这个类。

3. ArithmeticError

算术运算相关的错误基类。

• ZeroDivisionError: 除零错误（如1 / 0）。
• OverflowError: 数字运算超出范围。
• FloatingPointError: 浮点运算错误。

4. LookupError

查找相关的错误基类。

• IndexError: 访问序列时索引超出范围（如访问列表的第十个元素，但列表只有五个元素）。
• KeyError: 访问字典时使用的键不存在。

5. TypeError

对不支持的操作或数据类型进行处理时抛出的错误。例如，尝试将字符串和整数相加。

6. ValueError

当操作或函数接收参数类型正确但值不合适时抛出的错误。例如，将一个不能转换为整数的字符串转换为整数。

7. FileNotFoundError

在打开文件时，文件不存在的错误。

8. IOError

输入/输出操作失败的错误（在 Python 3 中已合并为 OSError）。

9. OSError

操作系统触发的相关错误，如文件不存在、磁盘满等。

10. ImportError

模块导入失败时抛出的错误。

11. NameError

当试图访问一个未定义的变量时抛出的错误。

12. AttributeError

当尝试访问一个对象中不存在的属性时抛出的错误。

13. IndexError

当尝试访问列表或元组中不存在的索引时抛出的错误。

14. KeyError

当尝试访问字典中不存在的键时抛出的错误。

15. StopIteration

用于指示迭代器没有更多的值可返回。

16. RuntimeError

发生在不属于其他异常类别的错误时。

17. SyntaxError

代码在解析阶段的语法错误，例如括号不匹配、缩进错误等。

18. IndentationError

当代码的缩进不正确时抛出的语法错误。

19. AssertionError

当assert语句失败时抛出的错误。

20. UnicodeError

与Unicode相关的编码和解码错误。

21. MemoryError

表示内存不足，无法分配更多空间的错误。

十一、文件操作

 使用open()函数打开文件时，需要指定文件路径和打开模式。打开模式决定了文件的访问方式，例如 读取、写入等。

格式：with open('example.txt', 'mode') as file:

mode格式如下:

'r'：只读模式（默认）
'w'：写入模式，如果文件存在则覆盖，不存在则创建新文件
'a'：追加模式，如果文件存在则在文件末尾追加内容，不存在则创建新文件
'b'：二进制模式，可以与其他模式组合使用，如'rb'、'wb'等

读取

read()：读取整个文件内容
readline()：读取一行内容
readlines()：读取所有行并返回一个列表
file = open('example.txt', 'r')
content = file.read() # 读取整个文件内容
print(content)
file.close() # 关闭文件

写入

write()：写入字符串内容
writelines()：写入字符串列表
file = open('example.txt', 'w')
file.write('Hello, World!') # 写入内容
file.close() # 关闭文件

高级用法：

使用上下文管理器 (with 语句)

使用 with 语句可以确保文件在使用后被自动关闭，即使发生异常也能保证资源的释放。

with open("example.txt", "r") as file:  
    content = file.read()  
    print(content)  # 不需要手动关闭文件

 读取大文件的分块处理

在处理大文件时，逐行读取或分块读取可以有效降低内存使用。

with open("large_file.txt", "r") as file:  
    for line in file:  
        # 处理每一行  
        print(line.strip())

文件读取模式

使用文件读取模式可以灵活处理不同编码的文件：

# 读取 UTF-8 编码的文件  
with open("example_utf8.txt", "r", encoding="utf-8") as file:  
    content = file.read()  

# 读取 GBK 编码的文件  
with open("example_gbk.txt", "r", encoding="gbk") as file:  
    content = file.read()

文件位置操作

使用 seek() 和 tell() 方法可以方便地控制和获取文件的当前位置。

with open("example.txt", "r") as file:  
    print(file.tell())  # 获取当前文件位置  
    file.seek(0)        # 移动到文件开头  
    print(file.read(5)) # 读取前5个字符

使用 pathlib 进行文件路径操作

pathlib 模块提供了一种面向对象的方式处理文件系统路径。

from pathlib import Path  

# 创建 Path 对象  
file_path = Path("example.txt")  

# 检查文件是否存在  
if file_path.exists():  
    print("文件存在")  
else:  
    print("文件不存在")  

# 读取内容  
with file_path.open("r") as file:  
    content = file.read()

文件内容的写入模式

除了基本的写入操作，还可以使用 append 和 w+ 模式。

# 追加写入  
with open("example.txt", "a") as file:  
    file.write("\n追加的内容")  

# 读写模式  
with open("example.txt", "w+") as file:  
    file.write("新的内容")  
    file.seek(0)  
    print(file.read())  # 读取新内容

使用 csv 模块处理 CSV 文件

对于 CSV 文件，可以使用内置的 csv 模块轻松处理。

import csv  

# 写入 CSV 文件  
with open("example.csv", "w", newline='') as file:  
    writer = csv.writer(file)  
    writer.writerow(["姓名", "年龄"])  
    writer.writerow(["Alice", 30])  
    writer.writerow(["Bob", 25])  

# 读取 CSV 文件  
with open("example.csv", "r") as file:  
    reader = csv.reader(file)  
    for row in reader:  
        print(row)

使用 json 模块处理 JSON 文件

json 模块允许你读写 JSON 格式的数据，易于与 Web API 进行交互。

import json  

# 写入 JSON 文件  
data = {"name": "Alice", "age": 30}  
with open("example.json", "w") as file:  
    json.dump(data, file)  

# 读取 JSON 文件  
with open("example.json", "r") as file:  
    data = json.load(file)  
    print(data)

文件压缩和解压缩

使用 zipfile 模块简化文件压缩和解压缩操作。

import zipfile  

# 压缩文件  
with zipfile.ZipFile("example.zip", "w") as zip_file:  
    zip_file.write("example.txt")  

# 解压缩文件  
with zipfile.ZipFile("example.zip", "r") as zip_file:  
    zip_file.extractall("extracted")

文件系统操作

使用 shutil 模块可以对文件进行拷贝、移动、删除等操作。

import shutil  

# 拷贝文件  
shutil.copy("example.txt", "copy_of_example.txt")  

# 移动文件  
shutil.move("copy_of_example.txt", "moved_example.txt")  

# 删除文件  
import os  
os.remove("moved_example.txt")

好啦，本章就介绍到这了，希望对你有所帮助。