python语言基础(四)--文件和异常

于 2024-08-20 10:18:13 发布
阅读量716 收藏 11
点赞数 20
分类专栏： Python语法 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/egglikeFe/article/details/141350971
版权

一、文件

(一)、文件概述

概述

我们所熟知的操作系统, 例如: Windows, MacOS, Linux 都是文件操作系统, 它们都是通过 文件 来管理数据的.

基本操作步骤

  • 打开文件.

  • 读取数据 或者 写入数据 或者 追加数据.

  • 关闭文件.

涉及函数

open(文件路径, 模式, 码表)
    参1: 文件路径, 可以写绝对路径, 也可以写相对路径.
        绝对路径: 固定的, 写死的路径, 以盘符开头.   d:/data/1.txt
        相对路径: 一般是相对于当前项目的路径来讲的.
            例如: 你写了 1.txt  这是一个相对路径, 它对应的绝对路径为: 当前项目的路径 + 1.txt, 具体如下:
                D:\workspace\pythonProject\practice\1.txt
    参2: 模式
        r:  只读, 默认模式, 可以读取 字符.  '你好'
        rb: 只读, 以二进制形式读取数据, 例如: 图片, 音频, 视频, 文本...
        w: 只写(覆盖写入), 可以操作 字符.
        wb: 只写(覆盖写入), 操作的是 字节.
        a: 追加写入, 可以操作 字符.
        ab: 追加写入, 操作的是 字节.

    参3: 码表
        码表 = 字符 + 其对应的int类型的整数, 例如: 'a' => 97, 'A' => 65, '0' => 48
        
       
read(num)       一次读取num个字节的数据, 不写num, 则一次性读取全部数据.  如果文件不存在就报错.
readlines()     一次性读取所有的行, 并把每行数据封装成1个字符串, 然后整体放到1个列表中, 即: [第一行数据, 第二行数据...]
readline()      一次读取一行数据, 并封装成字符串, 然后返回.
write(数据)			一次往文件中写入指定的内容, 不能是列表, 元组等多个值...
writelines(容器类型)   一次往文件中写入多个值, 必须是: 容器类型.

close()         关闭文件, 释放资源.

注意:

  • 上述的模式中, r, w, a 都是可以操作字符的, 即: 可以结合码表 encoding 一起使用.

  • 上述的模式中, rb, wb, ab都是操作二进制的, 所以不能结合 encoding参数 一起使用.

  • 码表 就是描述 字符 和 整数之间的关系的, 例如: ASCII, GBK, utf-8…

  • 在gbk码表中, 1个中文占2个字节, 在utf-8码表中, 1个中文占3个字节.

  • 数字, 字母, 特殊符号无论在什么码表中, 都只占 1个字节.

(二)、读

1、read()

格式

read(num)       一次读取num个字节的数据, 不写num, 则一次性读取全部数据.  如果文件不存在就报错

例如

# 1. 打开文件.
# 相对路径.
f = open('1.txt', 'r')

# 绝对路径
# 写法1: r''   取消\的特殊含义
# f = open(r'D:\workspace\pythonProject\practice\1.txt', 'r')
# 写法2: \\ => \
# f = open('D:\\workspace\\pythonProject\\practice\\1.txt', 'r')
# 写法3: 直接写 1个 /
# f = open('D:/workspace/pythonProject/practice/1.txt', 'r')

# 如果数据源文件不存在, 就会报错.
# f = open('2.txt', 'r')

# ./代表当前项目的路径, 可以省略不写.
# f = open('./data/2.txt', 'r')
f = open('data/2.txt', 'r')

# 2. 读取文件.
# data = f.read()     # 不写长度, 一次性读取所有的内容.
# data = f.read(2)      # 写长度, 则一次读取 2个字节.
# data = f.read(3)      # 写长度, 则一次读取 3个字节.
data = f.read(10)       # 写长度, 则一次读取 10个字节, 如果文件内容不足10个字节, 则读取全部内容.
print(data)

# 文件数据已经读取完毕, 如果继续读取, 则: 返回 ''
data2 = f.read(3)
print(data2)

# 3. 关闭文件.
f.close()

2、readline()

格式

readline()      一次读取一行数据, 并封装成字符串, 然后返回.

例如

# 1. 打开文件.
f = open('1.txt', 'r')

# 2. 读取文件数据.
# 方式1: readline(), 一次读取一行, 分解版写法.
line1 = f.readline()    # 'abc\n'
line2 = f.readline()    # 'def\n'
line3 = f.readline()    # 'g\n'
line4 = f.readline()    # ''

print(f'line1: {line1}', end='')
print(f'line2: {line2}', end='')
print(f'line3: {line3}', end='')
print(f'line4: {line4}', end='')

# 方式2: readline(), 一次读取一行, 合并版写法.
while True:
    # 一次读取一行数据.
    line = f.readline()
    # 判断读取到的数据是否为空, 如果为空, 说明文件内容读取完毕, 结束循环即可.
    # if len(line) == 0:
    # if not line:              # 0, None, '' => False, 其它 => True
    # if bool(line) == False:   # 0, None, '' => False, 其它 => True
    if line == '':
        break
    # 走到这里, 说明读取到数据了.
    print(f'line: {line}', end='')

# 3. 关闭文件.
f.close()

3、readlines()

格式

readlines()     一次性读取所有的行, 并把每行数据封装成1个字符串, 然后整体放到1个列表中, 即: [第一行数据, 第二行数据...]

例如

# 1. 打开文件.
f = open('1.txt', 'r')

# 2. 读取文件数据.
# 方式1: readlines(): 一次读取所有行, 每行封装成字符串, 然后整体封装成列表.
lines = f.readlines()
print(lines)        # ['abc\n', 'def\n', 'g\n']
print(type(lines))  # <class 'list'>

# 3. 关闭文件.
f.close()

4、读取中文

注意

  • 中文在gbk码表(针对于国内)中占 2 个字节, 在utf-8码表(针对于国际, 也叫: 万国码, 统一码)中占 3个字节.

  • 英文字母, 数字, 特殊符号无论在什么码表中, 都只占 1个字节.

  • 码表 = 字符 + 字符对应的整数, 码表就是描述 字符 及其 对应的整数之间的 关系的.

例如

# 1. 打开文件.
# f = open('1.txt', 'r')      # 默认的码表是: gbk码表.
# f = open('1.txt', 'r', encoding='gbk')    # 效果同上.

# 码表名可以写 utf-8 或者 utf8, 建议写: utf-8
# f = open('1.txt', 'r', encoding='utf8')

# rb: 以 二进制形式 读取文件, 报错, 二进制方式(无论读写), 不能结合 码表(encoding参数)一起用.
# f = open('1.txt', 'rb', encoding='utf8')

# 正确的 二进制 写法.
f = open('1.txt', 'rb')

# 2. 读取文件数据.
lines = f.readlines()
print(lines)

# 3. 关闭文件.
f.close()

(三)、写

1、write()

格式

write(数据)           一次往文件中写入指定的内容, 不能是列表, 元组等多个值...

例如

# 场景1: 字符方式 覆盖写入, 或者追加写入, 即: w, a 模式演示.
# 1. 打开文件.
# 只读模式, 如果文件不存在, 就报错.
# f = open('2.txt', 'r')

# 覆盖写入模式 或者 追加写入模式, 如果目的地文件不存在(前提: 父目录存在), 则会自动创建.
# f = open('2.txt', 'w')
# f = open('2.txt', 'a')

# 父目录存在
# f = open('./data/1.txt', 'w')   # 覆盖写入.
# f = open('./data/1.txt', 'a')   # 追加写入.

f = open('./data/1.txt', 'w', encoding='utf-8')   # 覆盖写入, 支持中文.

# 父目录不存在的情况.
# f = open('aa/bb/cc/2.txt', 'w')     # FileNotFoundError, 文件不存在.

# 2. 往文件中写数据.
f.write('abc\n')
f.write('def\n')
f.write('g\n')
f.write('好好学习!\n')  # 如果要写中文, 记得加上 encoding='utf-8'

# 3. 关闭文件.
f.close()



# 场景2: 字节方式 覆盖写入, 或者追加写入, 即: wb, ab 模式演示.
# 1. 打开文件.
# f = open('./data/1.txt', 'wb')   # 覆盖写入, 二进制形式
f = open('./data/1.txt', 'ab')   # 追加写入, 二进制形式

# 2. 往文件中写数据.
f.write(b'abc\n')
f.write(b'def\n')
f.write(b'g\n')
f.write(b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0!\n')  # 如果要写中文, 记得加上 encoding='utf-8'

# 3. 关闭文件.
f.close()

2、writelines()

格式

writelines(容器类型)   一次往文件中写入多个值, 必须是: 容器类型

例如

# 场景1: writelines() 一次写多行.
f = open('data/1.txt', 'w', encoding='utf-8')

# writelines() 要的是容器类型.
# f.writelines(['故人西辞富士康, \n', '为学技术到蓝翔!\n', '蓝翔毕业包分配,\n', '居然还是富士康!\n'])
f.writelines(('故人西辞富士康, \n', '为学技术到蓝翔!\n', '蓝翔毕业包分配,\n', '居然还是富士康!\n'))
f.writelines('abc')

# 如果操作字典, 则只写入: 键.
# f.writelines({'name': '张三', 'age': 23, 'gender': '男'})

# 报错: writelines()接收的是: 容器类型.
# f.writelines(10)
f.close()

注意：

  • 从打开 到 关闭, 这是一个完整的动作, 其内部是不会不断覆盖的.

  • 我们用 read(), readline() + write() 这种方式较多.
    而 readlines() + writelines() 这种方式相对较少, 它比较适合 小文件的操作.

(四)、编解码

概述

编码: 把我们看得懂的数据 => 我们看不懂的数据, 这个动作叫: 编码.
解码: 把我们看不懂的数据 => 我们看得懂的数据, 这个动作叫: 解码.

注意

  • 中文 => gbk(2个字节), UTF-8(3个字节), 数字,字母,特殊符号 => 无论什么码表, 都只占 1个 字节.

  • 只要出现乱码问题了, 原因只有1个: 编解码不一致.

  • 编解码涉及到的函数:
    encode(): 编码.
    decode(): 解码.

  • 二进制的特殊写法, b’内容’, 只针对于 数字, 字母, 特殊符号有效, 针对于 中文 无效.

例如

# 1. 演示 编码.
# s1 = 'abcXYZ123!@#'
s1 = 'aX1!你好'

# 具体的编码动作.
bys1 = s1.encode()                  # 默认码表(utf-8).  bys => bytes, 字节列表.
bys2 = s1.encode(encoding='gbk')    # 指定码表 => gbk
bys3 = s1.encode(encoding='utf-8')  # 指定码表 => utf-8

print(f'bys1: {bys1}')  # b'aX1!\xe4\xbd\xa0\xe5\xa5\xbd'
print(f'bys2: {bys2}')  # b'aX1!\xc4\xe3\xba\xc3'
print(f'bys3: {bys3}')  # b'aX1!\xe4\xbd\xa0\xe5\xa5\xbd'

# 打印类型
print(type(bys1))   # <class 'bytes'>
print(type(bys2))   # <class 'bytes'>
print(type(bys3))   # <class 'bytes'>
print('-' * 30)

# 2. 演示 解码
s2 = bys1.decode()                  # 默认码表(utf-8).
s3 = bys1.decode(encoding='gbk')    # 指定gbk码表
s4 = bys1.decode(encoding='utf-8')  # 指定utf-8码表

print(f's2: {s2}')
print(f's3: {s3}')  # 乱码, 因为: 编解码不一致.
print(f's4: {s4}')

print(type(s2))
print(type(s3))
print(type(s4))
print('-' * 30)

# 3. 演示 二进制的特殊写法.
bys4 = b'abcXYZ123!@#'
# bys4 = b'abcXYZ123!@#你好'    # 报错, b'内容' 只针对于 数字, 字母, 特殊符号有效, 针对于 中文 无效.
print(f'bys4: {bys4}')  # b'abc'
print(type(bys4))       # <class 'bytes'>

(五)拷贝与备份文件

1、拷贝文件

# 需求1: 把 data目录下的a.jpg => data目录下的b.jpg文件中.
# 1. 封装数据源文件, 获取: 文件对象.
src_f = open('data/a.jpg', 'rb')
# src_f = open('data/1.txt', 'rb')
# 2. 封装目的地文件, 获取: 文件对象.
dest_f = open('data/b.jpg', 'wb')
# dest_f = open('data/2.txt', 'wb')
# 3. 具体的拷贝动作.
# 思路3: 循环读取, 一次读取指定数量的数据, 然后写出到目的地文件中.
while True:
    # 一次读取指定数量的数据, 一般是: 1024 的整数倍.
    # bit(比特位), byte, kb, mb, gb, tb, pb, eb, zb, yb, bb, nb, db
    data = src_f.read(8192)   # 一次读取 8KB
    # 判断读取到的数据是否为空, 如果为空, 说明文件读完了, 结束循环即可.
    if not data:    # '' => False
        break
    # 走这里, 说明读取到数据了, 就写到目的地文件中.
    dest_f.write(data)

# 4. 释放资源.
src_f.close()
dest_f.close()

2、备份文件

# 方式1: 分解版写法.
# 1. 提示用户录入文件名.
file_name = input("请输入文件名: ")

# 2. 判断用户录入的文件名是否合法.
idx = file_name.rfind(".")        # 找.的最后一次出现的位置.
if idx <= 0:        # abc => -1,  .txt => 0
    print('文件名不合法, 程序结束!')
else:
    # 3. 走到这里, 说明文件名合法, 就拼接: 目的地文件名.
    dest_file_name = file_name[:idx] + '[备份]' + file_name[idx:]
    # print(dest_file_name)

    # 4. 具体的拷贝动作.
    src_f = open(file_name, 'rb')
    dest_f = open(dest_file_name, 'wb')
    while True:
        data = src_f.read(8192)
        if not data:
            break   # 走这里, 说明文件内容读取完毕.
        # 走这里, 说明有文件, 就写出
        dest_f.write(data)

    # 5. 释放资源
    src_f.close()
    dest_f.close()

    # 6. 提示用户.
    print('拷贝成功!')
 



# 方式2: 函数版.  抽取函数的快捷键 => ctrl + alt + m
def copy_file(src_file_name, dest_file_name):
    """
    自定义函数, 完成: 文件备份
    :param src_file_name: 数据源文件名
    :param dest_file_name: 目的地文件名
    :return: 无
    """
    # 1. 封装数据源 和 目的地文件.
    src_f = open(src_file_name, 'rb')
    dest_f = open(dest_file_name, 'wb')
    # 2. 具体的拷贝动作
    while True:
        data = src_f.read(8192)
        if not data:
            break  # 走这里, 说明文件内容读取完毕.
        # 走这里, 说明有文件, 就写出
        dest_f.write(data)
    # 3. 释放资源
    src_f.close()
    dest_f.close()

(六)with…open…

概述

是用来简化 文件操作的, 可以帮助我们自动释放资源

格式

with open(文件路径, 模式, 码表) as 别名:
    正常读文件数据 或者 写数据到文件

细节

  • with open()语法 会在其内部的代码执行完毕后, 自动释放资源, 无需手动释放

  • with open()语法的本质是 一个上下文管理器对象

例如

# 利用with...open...来简化上面的拷贝文件
# 1. 封装数据源文件, 目的地文件,  获取: 文件对象.
with open('data/a.jpg', 'rb') as src_f, open('data/b.jpg', 'wb') as dest_f:
    # 2. 具体的拷贝动作.
    while True:
        # 一次读取指定数量的数据, 一般是: 1024 的整数倍.
        data = src_f.read(8192)   # 一次读取 8KB
        # 判断读取到的数据是否为空, 如果为空, 说明文件读完了, 结束循环即可.
        if not data:    # '' => False
            break
        # 走这里, 说明读取到数据了, 就写到目的地文件中.
        dest_f.write(data)

# with open语法, 会在其内部的代码执行完毕后, 自动释放资源.

(七)os模块

概述

全称叫Operating System, 也叫: 系统模块, 主要是操作 文件, 文件夹, 路径等的

常用函数

getcwd()    获取当前工作目录, 即: 你写的相对路径, 都是相对于这个路径来讲的. get current work directory
chdir()     改变工作路径, 即: 相对路径以后就是相对于这个路径来讲的.
listdir()   查看当前目录下, 所有的子级(不包括子级的子级)
mkdir()     创建目录的, 如果存在就报错, 不存在就创建.
rename()    修改文件的名字.
remove()    删除指定的文件.

例如

# 导包
import os

# 演示os模块常用的函数.
# 1. 获取当前工作目录, 即: 你写的相对路径, 都是相对于这个路径来讲的.
print(os.getcwd())  # D:\workspace\pythonProject\practice

# 2. 设置当前的工作空间为指定的目录.
os.chdir('d:\\data\\')
os.chdir('d:/data/')

# 重新查看当前的工作空间.
print(os.getcwd())

# 读取文件内容.
f = open('1.txt', 'r', encoding='utf-8')
print(f.read())
f.close()

# 3. 查看当前目录下所有的文件(不包括子级的子级)
print(os.listdir('./'))     # 获取当前目录下所有的文件(不包括子级的子集)

# 4. 在指定目录下创建 子目录.
os.mkdir('./data/cheers')  # make directory: 制作目录, 该目录必须:不存在.

# 5. 改名.
os.rename('data/cheers', 'data/cheers_new')

# 6. 删除文件的.
os.remove('data/cheers_new/a.jpg')

(八)shutil模块

概述

它里边的函数, 大多数是和 文件(文件夹)相关的, 且大多数的函数 底层都支持递归.
例如: copyfile() 就可以实现 拷贝文件.

例如

# 扩展: shutil 模块.
import shutil

# shutil模块的 copyfile()函数可以实现: 拷贝文件.
shutil.copyfile('data/1.txt', 'data/2.txt')
shutil.copyfile('data/a.jpg', 'data/b.jpg')

二、异常

我们把程序中出现的所有非正常情况, 统称为: 异常. 俗称叫: Bug.程序会将异常的类型, 产生的原因, 以及异常的位置, 打印到控制台上.并终止程序的执行

(一)、捕获异常

概述

它指的是 try.except.finally 这个语法, 即: 手动处理异常

特点

手动处理之后, 程序会继续向下执行

格式

try:
    里边写可能出问题的代码
except:
    如果出问题了, 这里写的是 处理方式
  • 先执行try中的内容, 看有无问题.
  • 有问题, 则会立即跳转到 except语句中 执行.
  • 无问题, 则不会执行 except中的内容.
  • 无论是否有问题, 处理之后, 程序都会自动向下执行.

例如

# 需求: 尝试去读取 1.txt 文件中的数据, 如果文件不存在, 我们就创建.
try:
    # 这里写的是: 可能出问题的代码
    print('----- try 1 -----')
    src_f = open('1.txt', 'r')  # 这行代码有Bug
    print('----- try 2 -----')
    print(src_f)
except:
    # 这里写的是, 出问题后的解决方案
    # print('哎呀, 程序出问题了!')
    # 走这里, 说明文件不存在, 我们就创建它.
    src_f = open('1.txt', 'w')
    print('----- except -----')

print('看看我执行了吗!')

(二)、捕获指定异常

概述

它指的是 try.except.finally 这个语法, 即: 手动处理异常

特点

手动处理之后, 程序会继续向下执行

格式

try:
    里边写可能出问题的代码
except [Exception as e]:                          # 这里的[]表示 可选
    如果出问题了, 这里写的是 处理方式

  • 先执行try中的内容, 看有无问题.

  • 有问题, 则会立即跳转到 except语句中 执行.

  • 无问题, 则不会执行 except中的内容.

  • 无论是否有问题, 处理之后, 程序都会自动向下执行.

例如

# 你可能会遇到的一些异常.
# print(10 // 0)            # 除数不能为 0, ZeroDivisionError

# src_f = open('1.txt', 'r')  # 文件不存在, FileNotFoundError
# print(src_f)


# 需求: 尝试去读取 1.txt 文件中的数据, 如果文件不存在, 我们就创建.
# 场景1: 捕获指定的异常.
try:
    # 这里写的是: 可能出问题的代码
    print('----- try 1 -----')
     src_f = open('1.txt', 'r')  # 这行代码有Bug
    print('----- try 2 -----')
except FileNotFoundError:
    # 这里写的是, 出问题后的解决方案
    print('----- except 1 -----')
    src_f = open('1.txt', 'w')
    print('----- except 2 -----')


# 场景2: 捕获异常时, 异常的类型 和 异常出现的类型不匹配, 则: 捕获不到该异常.
try:
    # 这里写的是: 可能出问题的代码
    print('----- try 1 -----')
    src_f = open('1.txt', 'r')  # 这行代码有Bug
    print('----- try 2 -----')
except ZeroDivisionError:
    # 这里写的是, 出问题后的解决方案
    print('----- except 1 -----')
    src_f = open('1.txt', 'w')
    print('----- except 2 -----')


# 场景3: 捕获多个异常.
try:
    # 这里写的是: 可能出问题的代码
    print('----- try 1 -----')
    # src_f = open('1.txt', 'r')  # 这行代码有Bug
    print(age)
    print(10 // 0)                # 这行代码有Bug
    print('----- try 2 -----')
except (ZeroDivisionError, FileNotFoundError, NameError):
    # 这里写的是, 出问题后的解决方案
    print('哎呀, 程序出错了!')

# 场景4: 捕获所有的异常, 因为Python中的异常类型太多了, 我们不可能逐一编写(除非业务固定, 出的问题也固定), 一般会直接写: Exception
try:
    # 这里写的是: 可能出问题的代码
    print('----- try 1 -----')
    src_f = open('1.txt', 'r')  # 这行代码有Bug
    # print(age)
    # print(10 // 0)                # 这行代码有Bug
    print('----- try 2 -----')
except Exception:           # Exception是所有异常的父类, 即: 它代表所有的异常.
    # 这里写的是, 出问题后的解决方案
    print('哎呀, 程序出错了!')

# 场景5: 打印异常的信息.
try:
    # 这里写的是: 可能出问题的代码
    print('----- try 1 -----')
    # src_f = open('1.txt', 'r')  # 这行代码有Bug
    # print(age)
    print(10 // 0)                # 这行代码有Bug
    print('----- try 2 -----')
except Exception as e:           # Exception是所有异常的父类, 即: 它代表所有的异常.
    # 这里写的是, 出问题后的解决方案
    # print('哎呀, 程序出错了!')
    print(f"程序出错了, 原因是: {e}")


print('看看我执行了吗!')

(三)、捕获异常完整语句

概述

它指的是 try.except.finally 这个语法, 即: 手动处理异常

特点

手动处理之后, 程序会继续向下执行

格式

try:
    里边写可能出问题的代码
except [Exception as e]:                          # 这里的[]表示 可选
    如果出问题了, 这里写的是 处理方式
else:
    如果try中的内容无问题, 则会执行这里.
finally:
    无论try中是否有问题, 都会执行这里的内容.

  • 先执行try中的内容, 看有无问题.

  • 有问题, 则会立即跳转到 except语句中 执行.

  • 无问题, 则try中内容执行完毕后, 会跳转到else中执行.

  • 无论是否有问题, 最终都会执行finally中的内容.

  • 大白话总结:
    程序有问题: try => except => finally
    程序无问题: try => else => finally

例如

# 需求1: 演示 try.except完整格式代码.
try:
    print('----- try 1 -----')
    # print(10 // 0)
    print(10 // 2)
    print('----- try 2 -----')
except Exception as e:
    print(f'程序出问题了, 原因是: {e}')
else:
    print('很开心, 程序没有Bug, 我是else!')
finally:
    print('你们都在说什么, 无论你们执不执行, 我都会执行, 我是finally!')
print('-' * 30)


# 需求2: 加入异常处理后的, 文件备份的代码.
# src_f = open('data/3.jpg', 'rb')
# dest_f = open('data/4.jpg', 'wb')
# while True:
#     data = src_f.read(8192)
#     if not data:
#         break
#     dest_f.write(data)
# src_f.close()
# dest_f.close()

# 标记变量.
flag = False        # False => 文件对象创建失败.  True => 文件对象创建成功.
# global src_f
# global dest_f
try:
    # 可能出问题的代码
    src_f = open('data/1.jpg', 'rb')
    dest_f = open('d ata/4.jpg', 'wb')
    flag = True     # 说明 文件对象创建成功.
except Exception as e:
    # 出问题后的解决方案
    print(f'程序出错了, 原因是: {e}')
else:
    # try中代码无问题, 则会执行这里.
    while True:
        data = src_f.read(8192)
        if not data:
            break
        dest_f.write(data)
finally:
    # 无论try中是否有问题, 最终都会走这里, 一般用于: 释放资源.
    if flag:
        src_f.close()
        dest_f.close()
        print('文件对象已关闭!')
    print('程序执行结束了!')

(四)、异常的传递性

概述

异常是具有传递性的, 如果在某个函数内部有Bug, 且该函数没有处理, 则会传给该函数的调用者来处理.
依次类推, 逐级传递, 直至传到main函数中, 如果还不处理, 程序就会自动处理.
即: 先打印异常的类型, 描述信息, 位置到控制台上, 并终止程序的运行.

细节

  • 如果为了保证所有的异常都被处理了, 我们可以在main函数中对异常做处理.

  • 建议异常越早处理越好, 在哪里发生, 就在哪里处理.

例如

# 需求: 定义函数fun01(), 里边有Bug.  然后由fun02()函数调用fun01()函数, 且在main函数中调用 fun02()函数, 观察会出现什么情况.
# 1. 定义fun01()函数
def fun01():
    print('--- fun01函数 start ---')
    # 情况4: 在fun01函数中, 处理异常.
    try:
        # 有Bug
        print(10 // 0)
    except:
        pass
    print('--- fun01函数 end ---')

# 2. 定义fun02()函数, 调用fun01()函数
def fun02():
    print('--- fun02函数 start ---')
    # 情况3: 在 fun02函数中, 处理异常.
    # 调用fun01()函数
    fun01()
    # try:
    #     fun01()
    # except:
    #     pass
    print('--- fun02函数 end ---')

# 3. 在main函数中, 测试上述的内容.
if __name__ == '__main__':
    # 情况1: 直接调用 fun02()函数, 看看结果是啥.
    fun02()

    # 情况2: 在main中处理异常, 看看结果是啥.
    try:
        # 可能出问题的代码
        fun02()
    except:
        # 出现问题后的解决方案
        pass

    # 情况3: 在fun02()函数中, 处理异常, 看看结果是啥.
    fun02()

    # 情况4: 在fun01()函数中, 处理异常, 看看结果是啥.
    fun02()

    print('看看我执行了吗!')
电子海鸥
关注
  • 20
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python学习笔记 - 探索文件读写操作
Mr数据杨
05-03 8820
在本教程中，我们系统地探讨了Python中关于文件操作的核心概念和基本技巧。文件操作是编程中不可或缺的一部分，掌握它们能够帮助你在日常开发中处理数据、记录日志、管理配置等多种任务。文件操作只是Python编程的一部分，深入理解和掌握以下相关领域将进一步提升你的编程能力，例如文件和目录管理、数据持久化、异常处理和错误管理等等。通过这次学习，你应该已经具备了在Python中进行文件操作的基础能力。继续练习这些技巧，并在实际项目中应用它们，将有助于你进一步巩固和提升编程水平。
〖Python零基础入门篇㊶〗- Python中内置异常类型
易编橙 · 终身成长社群，相遇已是上上签！
03-14 4万+
上一章节我们学习了如何捕获异常，并且针对 通用异常 与 具体异常 的捕获进行了详细的讲解。今天给大家讲解一下 Python 中常用的内置异常类型的捕获，希望通过对它们的了解，可以帮助我们更好的使用并捕获异常。 该章节只有一个目的，那就是了解常用的异常类型。
Python基础---程序的控制结构
weixin_68864415的博客
05-30 2164
介绍python的基础
Python 基础（一）：入门必备知识
热门推荐
Python小二
10-30 112万+
Python 入门必备知识，你都掌握了吗？
Python011--异常
码到成龚的博客
10-18 1765
一，Exception异常 1，NameError(属于编译时异常) 2，IndexError（属于运行时异常） 3,AttributeError（属于运行时异常） 4，FileNotFoundError（属于运行时异常） 5，ZeroDivisionError（属于运行时异常） 二，捕获异常 三，抛异常 1，raise语句 2，assert语句 四，自定义异常
【Python】文件操作和异常处理
你不来，再美的天地，都狼藉 ~
02-03 3198
这篇文章带领大家一起学习Python中的文件操作和异常处理
Python学习笔记10-文件和异常（图文）
码出精彩
08-01 2617
文件和异常 1.从文件中读取数据 要使用文本文件中的信息，首先需要将信息读取到内存中。为此，你可以一次性读取文件的全部内容，也可以以每次一行的方式读取。 （1）读取整个文件 首先我们在Python37的目录下创建一个文件test.txt，如图 然后利用下面的程序打开并读取这个文件，再将其内容显示到屏幕上 filename = 'test.txt' with open(filename) as fi...
Python学习笔记 - Python语言概述和开发环境
yunfan
04-30 3071
Python简介和Python开发环境的搭建准备工作。
python编程基础-上海交通大学版答案
~本特利~的博客
07-01 3万+
~本特利~ B级模块 学习笔记 描点B ~本特利~
Python文件与目录-os模块和shutil模块详解
有一分热，发一分光。
03-01 1万+
os模块和shutil模块是Python处理文件/目录的主要方式。os模块提供了一种使用操作系统相关功能的便捷方式，shutil模块是一种高级的文件/目录操作工具。
02-python-模块和包-异常-警告-文件读写
02-08
综上所述，了解并熟练掌握Python的模块和包、异常处理、警告机制以及文件读写是成为一位合格的Python开发者的基础。这些知识不仅有助于编写高效、可维护的代码，还能在面对各种问题时提供有效的解决方案。
Python-语言入门-基础教程-自学.PDF
04-26
通过深入学习Python的基础知识，包括语法、数据类型、运算符、流程控制、函数和面向对象编程，你将能够熟练掌握这门语言，为未来的编程生涯打下坚实的基础。对于新手来说，可以从Python的安装开始，逐步学习并实践，...
Python语言基础：打开文件.pptx
05-04
Python是一种高级编程语言，以其...以上就是关于Python语言基础中打开文件的相关知识，包括`open()`函数的使用、文件模式、缓冲策略以及错误处理等方面的内容。理解并熟练掌握这些知识对于进行有效的文件操作至关重要。
信息技术-python-语言基础.doc
06-13
本教程将深入浅出地讲解Python语言的基础，帮助初学者快速入门。 首先，Python的基本语法和数据类型是编程的基石。Python中的变量可以用来存储各种类型的数据，包括数字（整数和浮点数）、字符串（用于文本处理）、...
CS31-Python:Python简介-练习和项目
03-19
Python是一种高级编程语言，以其简洁明了的语法和强大的功能深受程序员喜爱。"CS31-Python:Python简介-练习和项目"这个主题是针对初学者设计的，旨在帮助他们入门Python编程，通过实践练习和实际项目来巩固理论知识...
【Python】入门到放弃之第九章《字典》
MP13537560060的博客
08-15 709
这是本系列的第九章节内容，《字典》。在Python中，字典（Dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是可变的，意味着你可以在创建字典后添加、删除或修改其中的元素。字典的键（key）必须是唯一的，并且是不可变的（即，它们必须是不可变数据类型，如字符串、数字或元组，但不能是列表或字典等可变类型）。字典的值（value）则可以是任何数据类型，包括列表、元组、字典等。以上，就是Python中字典的全部内容。
【Python使用】嘿马头条项目从到完整开发教程第1篇：简介,1. 内容【附代码文档】
一诺的博客
08-16 617
本教程的知识点为:简介 1. 内容 2. 目标 产品效果 ToutiaoWeb虚拟机使用说明 数据库 理解ORM 作用 思考： 使用ORM的方式选择 数据库 SQLAlchemy操作 1 新增 2 查询 all() 数据库 分布式ID 1 方案选择 2 头条 使用雪花算法 （代码 toutiao-backend/common/utils/snowflake) 数据库 Redis 1 Redis事务 基本事务指令 Python客户端操作 Git工用流 调试方法 JWT认证方案 JWT & JWS & JWE
湖北师范大学-Python程序设计-3.1 中国古代数学问题(project)
最新发布
柠檬喝汽水的博客
08-19 442
唐朝时，一斗酒的斗所采用的度量是小斗，也就是4斤，当时一斤取值范围大约在500多到600克左右，换算一下可知唐朝一斗酒的重量取值范围在2000克到2400克左右。有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有 765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出不超过 n 且满足条件的物品个数 m，如果有多个解，则分行输出，每行一个解；第二行输出 2 个浮点数，依次为小鼠和大鼠打洞的距离，单位为尺，保留小数点后 1 位数字。一个浮点数 f，表示李白的酒壶原来有 f 斗酒。
SciPy：基于 NumPy 的算法库和数学工具包，用于数学、科学和工程领域。
LS_Ai的博客
08-15 973
无论是进行线性代数运算、优化问题求解、积分与微分方程处理，还是进行信号和图像处理，SciPy都提供了高度优化的工具，使得复杂的科学计算任务变得更加简单和高效。SciPy的目标是为用户提供一个全面的科学计算环境，其中涵盖了常见的线性代数、优化、积分、插值、傅里叶变换、信号处理、统计、图像处理、以及ODE（常微分方程）求解等功能。SciPy与NumPy紧密结合，同时也与Pandas、Matplotlib等库有很好的兼容性，这使得它在科学研究、数据分析和工程计算中占据了重要地位。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值