python 文件操作、代码异常

本章知识简介

主线A: 操作文件和目录
主线B: 异常处理

==本章目标：==

1:能够知道文件的使用步骤; [了解]
    a.打开文件
    b.读/写数据
    c.关闭文件
2:能够掌握如何以读的方式打开文件; [重点]
    open("xxx","r")
3:能够知道什么是异常; [了解]
    程序报错
4:能够知道try-except的作用; [重点]
    捕获异常

文件操作

[了解]什么是文件

==目标：==了解什么是文件？

如果要操作具体的文件以及文件内的数据内容，一起来看看文件类型。

说明：

（1）目录就是可以用于存放多个文件、目录的集合；[os模块]

（2）文件是用于记录数据内容的，通常是有后缀名的。[file对象]

我们已知道，文件可以用来存储数据。若根据文件内容的不同来给文件分类，可分为：

（1）文本类型：存放文字类数据，读写时使用r、w；

（2）二进制原始数据类型：存放二进制bytes数据，比如图片、音频、视频等，读写时使用rb、wb；

==总结：==

通常情况下，文件是有后缀名的，比如：.txt、.jpg等。

[掌握]操作文件的步骤

==目标：==掌握如何操作文件？

先来看看在现实生活中，怎么记录电子笔记？

（1）新建一个doc文件，使用办公软件打开；
（2）写入一些笔记，笔记写完了，然后保存信息；
（3）关闭办公软件。

类似地，在Python中操作文件记录信息的步骤：

（1）打开文件，或新建一个文件； open()
（2）读取或写入数据内容； read() / write()
（3）关闭文件。 close()

说明：

无论操作文件的过程多么复杂，这个步骤基本是一致的。

（1）打开文件

在操作一个文件前，需要先打开文件。

函数名	含义
open(name, mode)	创建一个新文件或打开一个已经存在的文件，name指的是文件名，mode指的是访问模式。

常见的mode访问模式有：

模式	描述
r	以读数据的方式打开文件，这是默认模式，可以省略。
rb	以读二进制原始数据的方式打开文件。
w	以写数据的方式打开文件。如果文件已存在，则打开文件写入数据是会覆盖原有内容。如果文件不存在，则创建新文件。
wb	以写二进制原始数据的方式打开文件。
a	使用追加内容形式，打开一个文件。通常用于写数据，此时会把新内容写入到已有内容后。

说明：

（1）访问模式r表示read，即读；

（2）访问模式w表示write，即写。

（2）读数据

在读取文件数据前，该文件必须已存在。

函数名	含义
read()	从某文件中，一次性读完整的数据。
readlines()	按行的方式把文件中的完整内容进行一次性读取，并返回一个列表。
readline()	一行一行读文件中的数据内容。

说明：

当访问模式有r时，可以读数据。

​
# 1、打开文件
# 这里文件路径后r是来说明后边的路径中\是普通字符，没有特殊函数，而不是转义字符
# 第二个参数r表示读模式，我要读取文件内容
file1 = open(r'E:\郑州大数据20期\file_test\a.txt','r',encoding='utf-8')
print(file1)
​
print('-----------读取文件全部数据-------------')
# 2、读取文件全部数据
file_data = file1.read()  # 从文件中读取所有数据,并返回
print(file_data)
​
print('-----------读取一行数据-------------')
# 3、读取一行数据
# 由于之前已经把文件的全部数据读取了，文件定位指针已经在文件末尾
# 这里需要将文件指针重新定位到开头
file1.seek(0)
file_line = file1.readline()
print(file_line)
​
print('-----------读每一行数据，并存入列表中-------------')
# 4、读取文件数据，并将每一行存入列表中
# 这里需要将文件指针重新定位到开头
file1.seek(0)
file_list = file1.readlines()  # 返回一个列表，列表中的元素是每一行数据，会每一行末尾的换行符
print(file_list)
for s1 in file_list:
 print(s1.strip())  # 去除每行的换行符
​
# 5、关闭文件
file1.close()

（3）写数据

在写文件数据前，文件若不存在，则创建一个新文件。

函数名	含义
write(seq)	给某文件写数据。

说明：

（1）当访问模式有w时，可以写数据；

（2）当使用访问模式a时，用于追加数据内容，也可以写入数据。

（4）关闭文件

当每次打开文件及使用完毕后，都需要进行关闭文件，用于释放系统内存资源。

函数名	含义
close()	关闭文件。

==总结：==

（1）读数据时使用r模式，写数据时使用（）模式；A、a；==B、w==；

（2）不管一个文件有多么复杂，操作步骤都是：打开文件、读/写数据、关闭文件。

[掌握]写数据

==目标：==掌握写入数据的使用。

给文件写入数据：

函数名	含义
write(seq)	给某文件写数据。

例如，一起来完成：

（1）给test.txt文件分别写入数据：Hello World、123456；

（2）思考1：如果要给文件写入内容：黑马程序员，会怎样？

（3）思考2：如果要在文件原有内容基础上，再追加内容：itheima，该怎么做呢？

# 1、打开文件
# 这里的r是来说明后边的路径中\是普通字符，没有特殊函数，而不是转义字符
# w是以写入的模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原内容
file1 = open(r'E:\郑州大数据20期\file_test\a.txt','a',encoding='utf-8')
print(file1)
​
# 2、向文件写入数据
file1.write('好好学习，天天向上!\n')  # 写入时，不会自动换行，你需要手动加换行符
​
# 3、关闭文件
file1.close()

==总结：==

（1）请问：当使用w模式操作文件时，可以不管文件是否已存在，这句话对吗？A、对；B、错；

（2）注意：如果要给一个文件写入中文内容，要记得设定文件的编码格式为utf-8。

[掌握]快捷读取数据

==目标：==掌握快捷读取内容的使用。

给文件读取数据：

函数名	含义
read()	从某文件中，一次性读完整的数据。

说明：

读取文件数据之前，要保证文件已经存在。

为了简化读写数据的操作，也可以使用语法：

with open(xxx, xx) as 变量名:
    变量名.read()
    # 变量名.write(xxx)

例如，一起来完成：

（1）读取hello.txt文件的数据内容，并输出；

（2）思考：若手动给hello.txt文件中添加了【深圳】，再读文件数据会出现什么情况呢？

# 这种写法使用完文件之后，我们不用手动关闭文件，系统会自动关闭文件，释放资源,并且自动处理异常情况
with open(r'E:\郑州大数据20期\file_test\a.txt','r',encoding='utf-8') as file1:
    file_data = file1.read()  # 从文件中读取所有数据,并返回
    print(file_data)
​
# 这种写法使用完文件之后，我们不用手动关闭文件，系统会自动关闭文件，释放资源,并且自动处理异常情况
with open(r'E:\郑州大数据20期\file_test\a.txt','a',encoding='utf-8') as file2:
    file2.write('eooigeegoegoegego')

==总结：==

（1）注意：当使用r模式操作文件时，文件必须已存在；

（2）如果要读取一个有中文内容的文件，需要设定文件的编码格式为（）。==A、utf-8==；B、gbk；

[了解]其他方式读数据

==目标：==了解读取数据的其他方式。

其他方式：

函数名	含义
readlines()	按行的方式把文件中的完整内容进行一次性读取，并返回一个列表。
readline()	一行一行读文件中的数据内容。

例如，一起来完成：

（1）读取hello.txt文件的数据内容，并输出；

（2）分别使用readlines()、readline()方式来完成。

# 1.打开文件
# file = open("./file/hello.txt","r")
file = open("./file/hello.txt","r",encoding="utf-8")
# 2.读数据
# readlines()
lines = file.readlines()  # ['hello python\n', 'abc\n', 'ABCDEFG\n', '123']
print(lines)
# readline()   # 1.当使用readxx()读取数据时, 指针偏移量开始处;  2.指针继续移动
# line = file.readline()
# print(line)
# line = file.readline()
# print(line)
# line = file.readline()
# print(line)
# line = file.readline()
# print(line)
# print("------------------------")
# line = file.readline()  # ""
# print(line)
# while True:
#     line = file.readline()
#     if len(line) == 0:  # \n
#         break
#     print(line)
​
# 3.关闭文件
file.close()

==总结：==

（1）常见读取文件数据的方式有：read()、readlines()；

（2）注意：当文件内的数据呈现很规律的一行一行内容时，可以优先考虑使用（）。==A、readlines()==；B、readline()；

[掌握]备份文件

==目标：==掌握如何备份文件内容。

备份文件指的是：将原文件的数据内容进行重新写入到另一个新文件中。

备份文件常应用：

例如，一起来完成：

（1）将a.txt文件进行备份处理；

（2）备份文件名为：b.txt。

print('-------------文本文件复制（自定义）：方式1----------------')
# 1、打开源文件(a.txt)和目标文件(b.txt)
with open('a.txt','r',encoding='utf-8') as file_src:
    with open('b.txt','w',encoding='utf-8') as file_dest:
        # 2、实现文件复制
        file_data = file_src.read()
        file_dest.write(file_data)
​
​
print('-------------文本文件复制（调用模块函数）：方式2----------------')
import shutil
​
# copy2函数既可以拷贝文件内容，也会拷贝a.txt的元数据（文件权限，访问日期.....）
shutil.copy2('a.txt','c.txt')
​
print('-------------二进制文件复制（自定义）：方式1----------------')
# 1、打开源文件(aaa.wmv)和目标文件(bbb.wmv)，视频是二进制文件，必须加b
with open('aaa.wmv','rb') as file_src:
    with open('bbb.wmv','wb') as file_dest:
        # 2、实现文件复制
        file_data = file_src.read()  # 从源文件读取数据
        file_dest.write(file_data)   # 把读取后的数据写入目标文件
​
​
print('-------------二进制文件复制（调用模块函数）：方式2----------------')
import shutil
​
# copy2函数既可以拷贝文件内容，也会拷贝aaa.wmv的元数据（文件权限，访问日期.....）
shutil.copy2('aaa.wmv','ccc.wmv')
​

==总结：==

（1）备份文件的操作，类似于操作系统中的复制、粘贴功能；

（2）请问：当要备份文件时，要注意读写文件的编码要保持一致，这句话正确吗？==A、正确==；B、错误。

os模块

[掌握]查看目录

==目标：==了解查看目录的使用。

Python中的os模块包含有操作系统所具备的功能，如查看路径、创建目录、显示文件列表等。

os模块是Python标准库，可直接导入使用：

# 导入os模块
import os

在Python中，os模块的常用函数分为两类：

（a）通过os.path调用的函数

（b）通过os直接调用的函数

在Python的os模块中，通过os.path常用函数：

函数名	含义
exists(pathname)	用来检验给出的路径是否存在。
isfile(pathname)	用来检验给出的路径是否是一个文件。
isdir(pathname)	用来检验给出的路径是否是一个目录。
abspath(pathname)	获得绝对路径。
join(pathname,name)	连接目录与文件名或目录。
basename(pathname)	返回单独的文件名。
dirname(pathname)	返回文件路径。

说明：

上述常用函数需要使用os.path来进行调用。

例如，使用os模块来完成：

（1）在某目录下手动新建day05/file目录与day05/file/hello.txt文件；

（2）判断file/hello.txt是否存在、是否是文件、是否是目录、获取绝对路径名、获取单独的文件名；

（3）执行程序，观察效果。

import os
​
print(os.path.exists('a.txt'))
​
# | isfile(pathname)    | 用来检验给出的路径是否是一个文件。 |
print(os.path.isfile('a.txt'))
​
# | isdir(pathname)     | 用来检验给出的路径是否是一个目录。 |
print(os.path.isdir('dir'))
​
# | abspath(pathname)   | 获得绝对路径。                     |
print(os.path.abspath('a.txt'))
# | join(pathname,name) | 连接目录与文件名或目录。           |
​
print(os.path.join(r'D:\work_space\python_project_gz\day05','b.txt'))
​
# | basename(pathname)  | 返回单独的文件名。                 |
print(os.path.basename(r'D:\work_space\python_project_gz\day05\b.txt'))
​
# | dirname(pathname)   | 返回文件父路径。                     |
print(os.path.dirname(r'D:\work_space\python_project_gz\day05\b.txt'))

==总结：==

（1）在Python中操作目录时，需要使用到os模块；

（2）注意：当要检查某目录是否存在时，可以使用（）方法。==A、exists()==；B、isfile()。

[掌握]目录的具体操作

==目标：==了解操作目录的方式有哪些？

在Python的os模块中，可直接通过os调用的常用函数：

函数名	含义
getcwd()	获得当前工作目录，即当前Python脚本工作的目录路径。
system(name)	运行windows下cmd的shell命令。
listdir(path)	返回指定目录下的所有文件和目录名，即获取文件或目录列表。
mkdir(path)	创建单个目录。
makedirs(path)	创建多级目录。
remove(path)	删除一个文件。
rmdir(path)	删除一个目录。
rename(old, new)	重命名文件。

说明：

上述常用函数可直接使用os来进行调用。

例如，使用os模块来完成：

（1）获取当前工作目录；

（2）获取day05/file下的文件或目录列表信息；

（3）思考：若要在file下新建hello/world/python目录，该怎么做呢？

# # | getcwd()         | 获得当前工作目录，即当前Python脚本工作的目录路径。       |
import os
print(os.getcwd())
​
# system(name)     运行windows的cmd中的shell命令
os.system('dir')  # 中文路径可能会出现乱码
​
# listdir(path)    返回指定目录下的所有文件和目录名，并存入列表中
print(os.listdir('E:\input'))
​
#  mkdir(path)      创建单个目录。
os.mkdir('dir2')
#  makedirs(path)   | 创建多级目录。
os.makedirs('dir11/dir22/dir33')
os.makedirs('dir11\\dir22\\dir33')
​
# remove(path)   删除一个文件。
os.remove('a.txt')
​
# | rmdir(path)      删除一个空目录。
import shutil
​
os.rmdir('dir')
​
#  shutil.rmtree(path)   删除一个非空目录,递归删除
shutil.rmtree('dir11')
​
# rename(old, new)  重命名文件。
os.rename('aaa.wmv','aaa2.wmv')

==总结：==

（1）当要遍历及获取某目录下的所有文件信息时，可以使用（）方法；==A、listdir()==；B、rmdir()；

（2）注意：当要涉及到操作目录，比如创建目录、检查目录是否存在等，就需要直接使用os模块。

异常介绍

[了解]什么是异常

==目标：==了解什么是异常？

异常指的是Python程序发生的不正常事件。

有时候，异常可称为错误。

当检测到一个错误时，Python解释器就无法继续执行，反而出现了一些错误的提示，这就是异常，也就是我们常说的BUG。

例如，一起来完成：

（1）定义一个列表变量；

（2）获取一个远超列表索引值的元素，报错：IndexError。

# # 1.正常
# print("Hello1")
# print("Hello2")
# # 2.异常
# datas = [1,2,3]
# print(datas[100])  # 崩溃
# print("Hello3")
# print("Hello4")
​
list1 = [1,2,3,4,5]
try:  # 加上 try  except 可以使程序遇到异常不会崩溃，回到正常状态，并给出提醒
    print(list1[88])  # IndexError
except:
    print('服务器一不小心走丢了，请稍后再试！')
​
print('程序结束')
print('ByeBye')

==总结：==

（1）通常情况下，Python异常的名称是以（）结尾；==A、Error==；B、Exception；

（2）注意：开发者往往是可以处理异常的。

[了解]制造常见的异常

==目标：==了解常见的异常有哪些？

为便于更快的了解Python异常，要了解并记忆异常信息。

例如，一起来完成：

（1）使用案例来制造出几个常见异常；

（2）比如：NameError、IndexError、KeyError、TypeError等。

# 1.fNameError: 直接使用未定义的变量
try:
    print(a)
    # 2.IndexError
    strs = "hello"
    print(strs[100])
​
    # 3.KeyError
    dicts = {}
    print(dicts["name"])
​
    # 4.TypeError
    print("hello" + 666)
    strs = "hello"
    print("结果:%d" % strs)
​
    # 5.FileNotFoundError ..
    open("./test.txt", "r")
​
except:
    print('程序出现了问题')
​
print('Byebye')

==总结：==

（1）当编程开发时，要把一些常见的异常记住，并掌握解决方案；

（2）实际上，当开发者能制造出对应的异常信息，往往他是能够解决的，反之则无法解决。

常见处理方式

[掌握]快速入门异常

==目标：==掌握异常的快速入门使用。

当程序中遇到了异常时，通常程序会出现崩溃情况。

为了不让程序崩溃，就可以使用异常来快速处理。

异常处理语法：

try:
    可能发生异常的代码
except:
    如果出现异常时, 执行的代码

说明：

try、except都是关键字，用于处理异常。

例如，一起来完成：

（1）制造出一个IndexError异常；

（2）使用异常来快速处理这段可能会产生IndexError的代码。

# 1.制造异常
# 2.处理
try:
    datas = [1,2,3]
    print(datas[100])  # 中断
except:
    print("已经发生了异常》。。")
print("Bye Bye")   # 当处理了异常后,程序可以稳定继续往后执行代码

==总结：==

（1）若要让程序不崩溃，可以使用（）快速处理异常。==A、try-except==；B、try-error；

[了解]捕获多个异常

==目标：==了解捕获多个异常的使用。

捕获异常是处理异常的标准形式。通常情况下，捕获异常分为三类：

（1）捕获一个指定异常

（2）捕获多个异常

（3）捕获所有异常

接着，来看看捕获一个指定异常的语法：

try:
    可能发生异常的代码
except 异常类型名:
    当捕获到该异常类型时，执行的代码

try:
    # 1.NameError: 直接使用未定义的变量
    print(a)
    # 2.IndexError
    strs = "hello"
    print(strs[100])
​
    # 3.KeyError
    dicts = {}
    print(dicts["name"])
​
    # 4.TypeError
    print("hello" + 666)
    strs = "hello"
    print("结果:%d" % strs)
​
    # 5.FileNotFoundError ..
    open("./test.txt", "r")
​
except NameError:  # 这里只能处理变量未定义异常，其他异常不能处理
    print('程序出现了问题')
​
print('Bye Bye')

捕获多个异常指的是：可以对一段可能发生异常的代码做多个异常类型的判断处理。

捕获多个异常语法：

try:
    可能发生异常的代码
except (异常类型1,类型2,...):
    如果捕获到该异常类型时,执行的代码

例如，一起来完成：

（1）有一段可能发生IndexError、KeyError的代码；

（2）使用多个except做异常处理；

（3）使用捕获多个异常的方式来处理代码片段。

try:
    # 1.NameError: 直接使用未定义的变量
    print(a)
    # 2.IndexError
    strs = "hello"
    print(strs[100])
​
    # 3.KeyError
    dicts = {}
    print(dicts["name"])
​
    # 4.TypeError
    print("hello" + 666)
    strs = "hello"
    print("结果:%d" % strs)
​
    # 5.FileNotFoundError ..
    open("./test.txt", "r")
​
except (NameError,IndexError,KeyError,TypeError,FileNotFoundError):  # 这里可以处理5种异常，其他异常不能处理
    print('程序出现了问题')
​
print('Bye Bye')

==总结：==

（1）当捕获多个异常时，可以将多个异常使用（）形式存放。==A、元组==；B、列表。

[掌握]捕获所有异常

==目标：==掌握捕获所有异常的使用。

要知道的是，Exception是表示所有程序异常类的父类，即使用Exception可以表示一切异常。

捕获所有异常语法：

try:
    可能发生异常的代码
except Exception[ as 变量]:
    当捕获到该异常类型时，执行的代码

说明：

Exception的首字母要大写。

例如，一起来完成：

（1）有一段可能发生异常的代码；

（2）使用捕获所有异常的形式来处理。

try:
    # 1.NameError: 直接使用未定义的变量
    print(a)
    # 2.IndexError
    strs = "hello"
    print(strs[100])
​
    # 3.KeyError
    dicts = {}
    print(dicts["name"])
​
    # 4.TypeError
    print("hello" + 666)
    strs = "hello"
    print("结果:%d" % strs)
​
    # 5.FileNotFoundError ..
    open("./test.txt", "r")
       # 类          对象
except Exception as error:  # 这里可以处理所有异常，会把异常信息保存到对象error中，可以打印
    print(error)  # 打印异常信息
​
print('Bye Bye')

==总结：==

（1）在捕获异常的三种方式中，而捕获所有异常的方式最简洁高效；

（2）在实际应用开发中，推荐使用捕获所有异常的方式来处理可能发生异常的代码。

[了解]异常的其他关键字

==目标：==了解异常其他关键字的使用。

在捕获异常过程中，有两个关键字else、finally需要注意：

else：表示如果没有异常时，要执行的代码；
finally：表示的是无论是否有异常，都要执行的代码。

当把else、finally都放入到捕获异常中，语法：

try:
    可能发生异常的代码
except 异常类型:
    当捕获到该异常类型时，执行的代码
else:
    没有异常信息时，执行的代码--->try 块成功完成后执行一些清理或后续操作。
finally:
    不管有没有异常，都会执行的代码（资源释放） --->它通常用于执行清理操作，如关闭文件、释放资源等

例如，一起来完成：

（1）有一段可能发生IndexError的代码片段；

（2）使用else关键字处理不发生异常的情况；

（3）使用finally关键字处理发生、不发生异常的情况；

（4）执行程序，观察效果。

# 1.制造异常
# 2.处理 指定异常
try:
    data = [1, 2, 3]
    print(data[100])
except IndexError:
    print("====1====已发生异常信息!")
else: # 3.else：没有发生异常时,处理的事情
    print("没有发生异常时,才会执行代码! !")
finally:# 4.finally：文件必须关闭
    print("无论有没有异常,都会执行finally!!")

==总结：==

（1）关键字else、finally可以配合异常处理一起使用；

（2）注意：当使用finally部分代码时，可以用于完成一些必须完成的操作，例如关闭文件、关闭系统资源等。[思考]

==思考：==例如，有一段代码，当执行结束后，结果是（ ==C== ）。

def test():
    try:
        strs = "abc"
        print(strs[60])
    except:
        return 1
    finally:
        return 2

A、程序出错 B、1 C、2 D、1 2

[掌握]异常具有传递性

==目标：==掌握异常可以进行传递。

例如，一起来完成：

（1）定义两个函数test()、func()；

（2）在一个函数中产生IndexError，同时在另一个函数中调用，观察效果。

==总结：==

（1）当一段可能发生异常的代码，发生了异常时，若不处理，则会传递给调用处；

（2）注意：标准的异常处理方式是（）。==A、捕获异常==；B、抛出异常；

(3) 处理异常，尽量在异常可能得发生地解决异常，不要随便把异常抛给它的调用者，这样出现异常会造成 更大范围的影响