Python进阶——文件、模块、包

Python进阶

文件操作

一、核心函数：open ()

语法：open(path, mode, encoding)

参数说明

1、path：文件路径

相对路径：如 "data.txt"（与代码文件同目录）

绝对路径：如 "C:/docs/data.txt" 或 r"C:\Users\chen\Document\a.txt"（Windows 用 r 转义反斜杠，或者不写r写两个反斜杠）

2、mode：打开模式（决定操作权限）

r：只读，文件不存在时报错

w：只写，文件不存在则新建，已存在则覆盖内容

a：追加，文件不存在则新建，已存在则追加新内容

r+：先读后写，光标在最后

w+：先写后读，光标在开头，会清空原有数据

a+：先追加再读，写入仅在结尾，每次读取会在结尾多加一轮

文本模式 t（默认省略）、二进制模式 b

3、encoding：文本模式下的编码（如 'utf-8'），二进制模式无需指定

二、文件写入方法

（一）f.write('string')：将字符串写入文件

示例：f.write('hello world!\n')

（二）用三个引号可保留原始格式：f.write('''格式什么样文件里就显示什么样''')

（三）f.writelines(list)：将列表中的数据写入文件

示例：f.writelines([str(i) + '\n' for i in range(5)])

三、文件读取方法

f.read(n)：读取字符串，不写参数默认读取所有，数字表示读取的字符数

f.readline()：每次读取一行数据

f.readlines()：以列表方式读取所有行

四、光标操作

f.seek(0)：光标移动到文件开头

f.tell()：显示当前光标位置（用字节数表示位置）

五、文件关闭与上下文管理器

第一种，手动关闭：文件使用后必须关闭，释放系统资源，否则可能导致数据丢失或文件占用

示例：f.close()

第二种，with 上下文管理器：帮助程序自动执行一些操作，例如关闭文件

with open('a.txt'):

    print(f.read())

    f.seek(0)

print(f.tell())

六、文件和目录管理（os 模块）

除了读写文件，os 模块提供了文件/目录的管理功能（如创建、删除、重命名）。

import os

# 1. 重命名文件/目录

os.rename("old.txt", "new.txt")  # 重命名文件

# 2. 删除文件

os.remove("delete_me.txt")  # 删除文件（需存在，否则报错）

# 3. 创建目录

os.mkdir("new_dir")   # 创建单层目录

os.makedirs("a/b/c")  # 递归创建多层目录

# 4. 删除目录

os.rmdir("empty_dir")  # 删除空目录

import shutil

shutil.rmtree("non_empty_dir")  # 删除非空目录（需导入shutil）

# 5. 查看目录内容

print(os.listdir("."))  # 列出当前目录所有文件和目录

# 可以使用os.path.exists()来检查文件是否存在。

import os

if os.path.exists("example.txt"):

    print("文件存在")

七、处理异常

在文件操作中，可能会出现各种异常情况，例如文件不存在或没有权限。在文件操作中捕获这些异常是个好习惯。

try:

    with open("example.txt", "r") as file:

        content = file.read()

except FileNotFoundError:

    print("文件不存在")

except Exception as e:

    print(f"发生错误：{e}")

---

Python模块和包

MVC：

M模型：和数据库进行交换

V视图：显示内容

C控制器：接收请求，返回响应

模块

什么是模块？

模块是一个以 .py 为扩展名的 Python 文件，包含函数、类、变量和可执行代码。简单来说：一个.py文件就是一个模块。

模块的作用

代码复用：将常用功能（如工具函数、类）封装到模块中，其他程序可直接导入使用，无需重复编写。

模块化管理：将复杂程序拆分为多个模块，每个模块负责单一功能，逻辑更清晰。

避免命名冲突：不同模块中可存在同名函数/变量，通过“模块名.成员”的方式访问，避免冲突。

模块的导入

import 模块名

模块名.变量 / 模块名.函数

from 模块名 import 变量名/函数名/*

import math

from math import pi, e, pow, sin, cos as π

print(math.pi)

模块的分类：

1.自定义模块（用户自己编写）

2.Python自带模块 D:\\APP\\Python\\lib

3.第三方模块     D:\\APP\\Python\\lib\\site-packages

pip install 模块名    # 安装第三方模块

pip list              # 查看已安装模块

pip freeze            # 显示安装模块的版本

pip uninstall 模块名  # 卸载第三方模块

包（Package）

包：模块的集合

包是一个包含多个模块的目录，且目录中必须有一个 __init__.py 文件（用于标识该目录是 Python 包），这个文件可以为空，但必须存在。

简单来说：一个带 __init__.py 的目录 = 一个包，用于组织多个相关模块。

作用：

1.将一系列模块进行分类管理，有利于防止命名冲突

2.可以在需要时加载一个或部分模块而不是全部模块

包的导入

import 包名

import 包名.模块名

# 导入包内的所有子包和模块

from 包名 import *

from 包名.模块名 import *

__init__.py 文件的作用

__init__.py 是包的标识文件，可为空，也可包含代码（用于控制包的导入行为）： 标识作用：告诉 Python 该目录是一个包，否则会被视为普通目录。

初始化作用：包被导入时，会自动执行 __init__.py 中的代码（如定义包的公开接口）。

控制导入：通过 __all__ 变量指定 from package import * 时可导入的模块

补充学习：

虚拟环境有什么作用？

· 虚拟环境可以让系统Python环境保持纯洁，干净，避免包的混乱和版本的冲突。

· 专为不同的项目搭建不同的环境，为每个项目使用虚拟环境可以保证项目只访问虚拟环境中的包，从而保持全局解释器的干净整洁，使其只作为创建虚拟环境的源。

· 使用虚拟环境不需要管理员权限。

· 多个虚拟环境同时进行，如同你拥有了多个Python解释器。

为什么要使用虚拟环境？

虚拟环境存在的意义只是为了将项目独立，使用虚拟环境的优势就是，该项目使用的第三方工具都需要在虚拟环境中使用pip命令安装，并且安装好的工具不影响系统已有的工具，同时系统中的其他项目也无法调用虚拟环境中安装的工具

如何搭建虚拟环境？（简单版）

# 1. 创建项目目录
mkdir myproject && cd myproject

# 2. 创建虚拟环境
python3 -m venv venv

# 3. 激活环境
source venv/bin/activate
# 提示符会显示 (venv)

# 4. 安装所需包
pip install flask pandas

# 5. 导出依赖
pip freeze > requirements.txt

# 6. 退出环境
deactivate

常用模块类型

sys（系统交互）

功能：获取命令行参数、控制解释器行为、退出程序等。

import sys # 导入Python的内置sys模块（系统交互工具）

print(sys.path) # 打印Python的模块搜索路径（告诉解释器去哪里找要导入的模块）

# 前提：在网站pypi上下载模块

Python导入模块的三种方式：

第一种：直接导入整个模块

第二步：给模块起别名（简化调用）

import my_module

print(my_module.add(2,3)) # 调用my_module里的add函数（计算2+3）

print(my_module.version) # 打印my_module里的version变量（模块版本）

calc = my_module.Calculator() # 创建my_module里Calculator类的实例

print(calc.divide(6, 2)) # 调用实例的divide方法（计算6÷2）

import my_module as mm # 给模块起别名（简化调用）

print(mm.multiply(3,4)) #用别名mm调用模块里的multiply函数（计算3×4）

from my_module import add,Calculator # 只导入模块里的特定内容（不用写模块名）

print(add(5, 5)) # 直接调用导入的add函数（计算5+5）

calc = Calculator() # 直接用导入的Calculator类创建实例

print(calc.divide(10, 5)) # 调用实例的divide方法（计算10÷5）

import sys

print(sys.version)

print(sys.argv) # 获取选项

argv_list = sys.argv

if len(argv_list) > 1:

    if '-a' in argv_list:

        print("Hello ALL")

    if '-b' in argv_list:

        print("BBBBBB")

else:

    print("请添加-a,-b选项！！")

sys.path.append('D:\\Code')

sys.path.insert(0,'D:\\Windows')

print(sys.path) # 显示模块所在路径

os（文件操作）

import os

print(os.getcwd())  # 获取当前目录的路径

open('a.txt','w')

os.chdir('D:\\')    # cd到D盘

print(os.getcwd())

# 执行系统命令

print(os.system(r'ipconfig'))

print(os.system(r'ping www.qq.caom'))

new_path = os.path.join(r'D:\usr\local','abc')

print(new_path)

math（数学运算）

import math # 数学模块

print(math.pow(2,3))

print(math.log2(4))

print(math.e)

print(math.sqrt(3))

# random随机数模块

print(random.random())  # 随机一个小数

print(random.randint(1,10)) # 包括1~10

print(random.randrange(10)) # 10以内的，不包括10

# 随机验证码

def make_code(n):

    code = ''

    for i in range(n):

        if random.randint(0,1) == 0:

            code += str(random.randint(0,9))

        else:

            code += chr(random.randint(65,91))

    return code

print(make_code(6))

time模块

# time 获取时间

import time

# 时间戳 <-> 时间元组 <-> 时间字符串

# print(time.time())  # 获取当前时间戳，从1970-1-1 00:00:00开始算

stat_time = time.time()

s = 0

for i in range(10000):

    for j in range(10000):

        s += i + j

print(s)

end_time = time.time()

print(f"执行时间:{end_time - stat_time}")

# 时间元组

print(time.gmtime())    # 标准时间元组

print(time.localtime()) # 本地时间元组

print(time.localtime(123456)) # 将数字转换为时间元组

tup_time = time.localtime()

# print(tup_time.tm_year,tup_time.tm_mon,tup_time.tm_mday)

print(time.strftime('%Y-%m-%d %H:%M:%S'))   # 时间字符串

# print(time.strftime('%Y-%m-%d %H:%M:%S',time.gmtime()))

t = time.strptime('2008-8-8 8:08:00','%Y-%m-%d %H:%M:%S')

print(time.mktime(t))

datetime（时间处理）

datetime.datetime：日期+时间（如 `2023-10-01 15:30:00`）

datetime.date：仅日期（如 `2023-10-01`）

datetime.time：仅时间（如 `15:30:00`）

datetime.timedelta：时间差（用于加减日期）

import datetime

# 获取当前时间

print(datetime.datetime.now())

now = datetime.datetime.now()

print(now.strftime('%Y年%m月%d日 %H:%M:%S'))

# 获取3天前的时间

print(now + datetime.timedelta(days=3))

# 获取昨天的时间

print(now - datetime.timedelta(days=1))

若出现`ModuleNotFoundError: No module named 'yaml'`的原因是你的 Python 环境中没有安装`PyYAML`库

# 打开终端，执行安装命令

pip install pyyaml

# 如果系统中有多个Python版本（如Python2和Python3共存），需用pip3代替pip

pip3 install pyyaml

# 若遇到网络问题，可使用国内镜像源（如阿里云）加速安装

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

re模块：正则表达式

功能：字符串匹配、查找、替换、分割等（处理复杂文本）。

import re

# 常见的元字符

.   匹配任意字符

[]  配一个范围内的字符 [0-9] [a-z] [A-Z]

[^] 反向匹配这个范围外的内容

\d  匹配任意一个数字[0-9]

\D  匹配任意一个非数字[^0-9]

\w  匹配任意字母、数字、下划线

\W  匹配一个任意非字符

\s  匹配空白符（空格、\t、\n等）

\S  匹配非空白符

# 匹配重复次数的元字符

*  匹配任意次0~∞

+  匹配1到任意次1~∞

?  匹配0~1,写在数量词后表示非贪婪模式

{n,m} 匹配n~m次

{n}   精确匹配n次

{n,}  匹配n到无限次

# 边界匹配

^ 以什么开头

$ 以什么结尾

\b 匹配单词边界（单词与非单词的交界）

\B 匹配非单词边界

贪婪模式:尽可能多的匹配，根据范围上限匹配（默认）

非贪婪模式:尽可能少的匹配，根据范围的下限匹配，在数量词后加？

# Python re 模块常用函数

1、re.match验证字符串完全匹配规则，开头匹配

phone = '12345678901'

res = re.match('\d{11}', phone)

print(res.group())

phone = '12345678901111111'

res = re.match('\d{11}', phone[0:11])

print(res.group())

2、re.search用于查找第一次匹配到的结果

phone = 'aaaa567890111111111'

res = re.search('\d{11}', phone)

print(res.group())

3、re.findall找到所有符合规则的字符，返回列表

text = "age: 18, score: 95, weight: 60"

nums = re.findall(r"\d+", text)  # \d+ 匹配1个或多个数字

print(nums)

4、re.sub替换敏感词（用*代替）

sensitive = "垃圾、笨蛋"

text = "这人真是笨蛋，说的都是垃圾"

censored = re.sub(r'垃圾|笨蛋', '*', text)

print("过滤后：", censored)  # 输出：这人真是*，说的都是*

5、re.split分割字符串，返回列表

text = "a,b,c,d"

parts = re.split(r"[,]", text)  # 匹配逗号或空格

print(parts)  # → ['a', 'b', 'c', 'd']

text = "1a3b5c4de"

parts = re.split(r"[\d]", text)  # 匹配任意数字

print(parts)  # ['', 'a', 'b', 'c', 'de'] → 以1分割，分割点左边是空的

6、re.compile编译

功能：编译正则表达式模式为正则对象（RegexObject），可重复使用（提高效率，尤其多次匹配时）。

# 编译模式（只做一次）

pattern = re.compile(r"\d+")

# 重复使用编译后的对象

print(pattern.findall("age: 18"))  # → ['18']

print(pattern.findall("score: 95"))  # → ['95']

7、hashlib模块

import hashlib

hashlib.md5()  # 创建MD5哈希对象

hashlib.sha1()  # 创建SHA-1哈希对象

code = hashlib.sha256('123'.encode('utf-8')) # 创建SHA256哈希对象，并初始化数据（'123'转成UTF-8编码的字节）

code.update('����'.encode('utf-8')) # 向哈希对象中追加数据（追加了表情符号'��'的UTF-8编码字节）

print(code.hexdigest())  # 生成最终的16进制哈希值并打印，也就是一长串数字字母，如果用digest()则返回字节形式的哈希值

hashlib.sha512()

def create_password(string):

code = hashlib.sha256(string.encode('utf-8'))

code.update('����'.encode('utf-8'))

return code.hexdigest()

print(create_password('root123'))