文件操作、异常、模块
目录
一、文件操作
1、什么是文件
如果要操作具体的文件以及文件内的数据内容，一起来看看文件类型。
说明：
（1）目录就是可以用于存放多个文件、目录的集合；[os模块]
（2）文件是用于记录数据内容的，通常是有后缀名的。[file对象]
俗话说：好记性不如烂笔头，可见记录笔记的重要性。
其实，不仅人类的大脑会遗忘事情，计算机也会如此。而计算机记录笔记的形式，就可以使用文件。
使用计算机来操作文件，就是把一些数据内容存放起来，可以让程序下一次执行时，直接使用已保存的数据。
我们已知道，文件可以用来存储数据。若根据文件内容的不同来给文件分类，可分为：
（1）文本类型：存放文字类数据，读写时使用r、w；
（2）二进制原始数据类型：存放二进制bytes数据，比如图片、音频、视频等，读写时使用rb、wb；
2、操作文件的步骤
先来看看在现实生活中，怎么记录电子笔记？
（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:\bigdata\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() | 关闭文件。 |
总结：
不管一个文件有多么复杂，操作步骤都是：打开文件、读/写数据、关闭文件。
3、写数据
给文件写入数据：
| 函数名 | 含义 |
|---|---|
| write(seq) | 给某文件写数据。 |
总结：
（1）请问：当使用w模式操作文件时，可以不管文件是否已存在，这句话对吗？对
（2）注意：如果要给一个文件写入中文内容，要记得设定文件的编码格式为utf-8。
4、快捷读取数据
给文件读取数据：
| 函数名 | 含义 |
|---|---|
| read() | 从某文件中，一次性读完整的数据。 |
说明：
读取文件数据之前，要保证文件已经存在。
为了简化读写数据的操作，也可以使用语法：
with open(xxx, xx) as 变量名:
变量名.read()
# 变量名.write(xxx)总结：
（1）注意：当使用r模式操作文件时，文件必须已存在；
（2）如果要读取一个有中文内容的文件，需要设定文件的编码格式为utf-8
5、其他方式读数据
其他方式：
| 函数名 | 含义 |
|---|---|
| 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）注意：当文件内的数据呈现很规律的一行一行内容时，可以优先考虑使用readline().
6、备份文件
备份文件指的是：将原文件的数据内容进行重新写入到另一个新文件中。
备份文件常应用：
例如，一起来完成：
（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）当要备份文件时，要注意读写文件的编码要保持一致
二、os模块
1、查看目录
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）注意：当要检查某目录是否存在时，可以使用exists()方法。
2、目录的具体操作
在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）当要遍历及获取某目录下的所有文件信息时，可以使用listdir()方法；
（2）注意：当要涉及到操作目录，比如创建目录、检查目录是否存在等，就需要直接使用os模块。
三、异常介绍
1、什么是异常
异常指的是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异常的名称是以Error结尾；
（2）注意：开发者往往是可以处理异常的。
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）实际上，当开发者能制造出对应的异常信息，往往他是能够解决的，反之则无法解决。
四、常见处理方式
1、快速入门异常
当程序中遇到了异常时，通常程序会出现崩溃情况。
为了不让程序崩溃，就可以使用异常来快速处理。
异常处理语法：
try:
可能发生异常的代码
except:
如果出现异常时, 执行的代码说明：
try、except都是关键字，用于处理异常。
例如，一起来完成：
（1）制造出一个IndexError异常；
（2）使用异常来快速处理这段可能会产生IndexError的代码。
# 1.制造异常
# 2.处理
try:
datas = [1,2,3]
print(datas[100]) # 中断
except:
print("已经发生了异常》。。")
print("Bye Bye") # 当处理了异常后,程序可以稳定继续往后执行代码总结：
若要让程序不崩溃，可以使用try-except快速处理异常。
2、捕获多个异常
捕获异常是处理异常的标准形式。通常情况下，捕获异常分为三类：
（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）当捕获多个异常时，可以将多个异常使用元组形式存放。
3、捕获所有异常
要知道的是，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）在实际应用开发中，推荐使用捕获所有异常的方式来处理可能发生异常的代码。
4、异常的其他关键字
在捕获异常过程中，有两个关键字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!!")总结：
关键字else、finally可以配合异常处理一起使用；
注意：
当使用finally部分代码时，可以用于完成一些必须完成的操作，例如关闭文件、关闭系统资源等。
思考：例如，有一段代码，当执行结束后，结果是（ ==C== ）。
def test():
try:
strs = "abc"
print(strs[60])
except:
return 1
finally:
return 2
# A、程序出错 B、1 C、2 D、1 25、异常具有传递性
例如，一起来完成：
（1）定义两个函数test()、func()；
（2）在一个函数中产生IndexError，同时在另一个函数中调用，观察效果。
print('------------解决异常方式1-在异常发生地解决(推荐)-----------------------')
def func1():
try:
print(1/0)
except:
print('func1发生了异常')
print('func1程序结束') # 这句话会执行
def func2():
func1()
func2()
print('------------解决异常方式2-直接调用者解决-----------------------')
def func1():
print(1 / 0)
print('func1程序结束') # 这句话不会执行
def func2():
try:
func1()
except:
print('func1发生了异常')
print('func2程序结束') # 这句话会执行
func2()
print('------------解决异常方式3-间接调用者解决-----------------------')
def func1():
print(1 / 0)
print('func1程序结束')
def func2():
func1()
print('func2程序结束') # 这句话不会执行
try:
func2()
except:
print('func2发生了异常')总结：
（1）当一段可能发生异常的代码，发生了异常时，若不处理，则会传递给调用处；
（2）注意：标准的异常处理方式是捕获异常。
(3) 处理异常，尽量在异常可能得发生地解决异常，不要随便把异常抛给它的调用者，这样出现异常会造成 更大范围的影响
五、导入模块
1、导入模块的方式
模块指的是：以.py结尾的Python文件。
注意：模块名属于标识符。
在模块中，能定义函数、变量和类等，也能包含其他一些可执行的代码，比如print(xxx)、import xx等。
使用模块前，要先导入模块。
导入模块有3种方式：
import 模块名1[, 模块名2...]
from 模块名 import 功能1[, 功能2, 功能3...]
from 模块名 import *
2、import xxx
import 模块名1
import 模块名2
......此外，也可以使用：
import 模块名1[, 模块名2, ...] # 不推荐调用模块中的函数语法：
模块名.函数名([值1, 值2, ...])为便于操作导入模块。来看看math模块的函数：
| 函数名 | 含义 |
|---|---|
| pow(x, y) | 返回x^y^（x的y次方）的值。 |
| sqrt(x) | 返回数值x的平方根。 |
例如，一起来完成：
（1）使用import导入math模块；
（2）求解2^10^ = 1024的值；
（3）求解9的平方根为多少？
# 1.导入模块
import math # 升级: 声明、定义
# 2.求解次方
print(math.pow(2,10))
# 3.求解平方根
print(math.sqrt(9))
# def func():
# import random
# print(random.randint(0,10))
# pass总结：
（1）建议使用import直接导入模块时，放在py文件的顶部
（2）建议使用import导入模块时，一行导入一个模块。
3、from xx import xx
from xx import xx导入模块功能语法：
from 模块名 import 功能1[, 功能2, 功能3...]此外，也可以使用：
from 模块名 import 功能1 # 不推荐
from 模块名 import 功能2
......调用模块中的功能语法：
功能1()
功能2()为便于操作导入模块。来看看math模块的函数：
| 函数名 | 含义 |
|---|---|
| ceil(x) | 返回数值x的上入整数，如math.ceil(6.3)返回7。 |
| floor(x) | 返回数值x的下舍整数。 |
例如，一起来完成：
（1）使用from - import导入math模块的几个功能；
（2）求解3.14的上入整数；
（3）求解3.14的下舍整数。
# 1.导入模块
from math import ceil,floor
# 2.上入
print(ceil(3.14))
# 3.下舍
print(floor(3.14))总结：
当要使用某模块中的几个功能时，可以使用【from 模块名 import 功能1[, 功能2, 功能3...]】一次导入。
4、from xx import *
from xx import *导入模块语法：
from 模块名 import *说明：
表示导入所有功能。
例如，一起来完成：
（1）使用from - import *导入模块；
（2）求解8的平方根、10^3^的值；
（3）思考：若要使用π，可以怎么做？
# 1.导入所有
from math import *
# 2.使用
print(sqrt(8)) #? 疑问
print(pow(10,3))
# 3.思考？
print(pi) # 1.不好阅读程序; 2.采用导入所有的形式会影响性能
print(e)总结：
（1）在Python语言中，*通常表示所有
（2）注意：不推荐使用from xx import *导入模块，因为导入模块中所有功能时，加载缓慢。
5、导入模块的别名
导入模块时，也可以给模块或功能取别名，语法：
import 模块名 as 别名
from 模块名 import 功能 as 别名
例如，一起来完成：
（1）使用math模块来求解2^10^的值、9的平方根；
（2）分别给import和from - import取别名来导入模块，并完成求结果；
（3）思考：若还想要使用模块名的形式来求解16的平方根，该怎么做呢？
# 1.导入模块 import
# 2.from -import
import math as m # 给模块起别名
from math import sqrt as sq # 给模块下的函数起别名
from math import pow as po # 给模块下的函数起别名
import math # 重新导入
print(m.sqrt(9))
print(m.pow(2,10))
print(sq(9))
print(po(2,10))
# 3.模块名
print(math.sqrt(16))总结：
（1）当取了别名后，则只能使用别名来调用功能或函数；
（2）注意：给导入的模块取别名时，语法是：as
六、制作模块
1、定义与调用模块
有时候，模块也称为库，当一个模块具有强大功能时，也可称为框架。
在Python中，模块分为三类：
（1）自定义模块：定义后，直接使用；
（2）标准库：直接导入使用；
（3）扩展库（第三方库）：需要先安装库，然后再使用。
通常地，每个Python文件都可以作为一个自定义模块而存在。
而开发者可以给自定义模块完成某些特定功能，比如求和、验证是否登录成功等等。
注意：给模块名取名时，建议所有字母均小写。
例如，一起来完成：
（1）新建一个Python文件，命名为mytool.py；
（2）在模块中，定义add()函数用于求解两数之和；
（3）接着，再定义一个模块来调用mytool.py下的add()函数求和。
# 定义函数
def add(a, b):
c = a + b
print(f"两数之和为:{c}")
# 1.导入自定义模块名
import mytool
# 2.调用函数
mytool.add(10,20)总结：
（1）当一些功能比较通用且频繁使用时，可以采用自定义的形式把功能进行封装在自定义模块中；
（2）注意：自定义模块名不要与Python已有库名相同，否则会出错。
2、__name__变量
我们知道，为了提升程序的稳定性。当编写完一个自定义模块的功能后，需要在模块中添加一些测试代码。
而当再另一个模块中调用自定义模块时，会发现：刚刚添加的测试代码也会一并执行。该怎么解决呢？
说明：
此时，就要来了解
__name__变量的使用。
注意：每个模块中都有的
__name__变量，语法：（1）当__name__在当前模块下测试输出结果：__main__ （2）当在另外的模块里调用输出时,结果：当前模块名
通常地，在测试代码时，需要添加判断__name__变量的语法：
if __name__ == "__main__":
代码
...说明：
前后是双下划线。
例如，一起来完成：
（1）拷贝mytool.py文件，并取名mytool2.py；
（2）给mytool2.py文件添加测试代码，测试求和效果；
（3）在另一个模块中调用求和函数，观察效果；
（4）思考：该怎么解决这个问题呢？
# 定义函数
def add(a, b):
c = a + b
print(f"两数之和为:{c}")
# if __name__ == "__main__":
# print(__name__) # 当前: __main__
# # 测试
# add(199,100) # 测试
# main + Enter
if __name__ == '__main__':
add(199, 100)
# 1.导入自定义模块名
import myutil # __name__： myutil
# 2.调用函数
myutil.add(10,20)总结：
（1）请问：在调用执行代码时，建议放在
if __name__ "__main__":下，这句话正确吗？==A、正确==；B、错误。
3、__all__变量
当一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素。
语法：
__all__ = ["函数名1","函数名2",xxx]说明：
可以使用
__all__变量来限定*的范围。
例如，一起来完成：
（1）定义myutil.py模块，有4个函数：求和、求差、求积、求商；
（2）在myutil.py模块中定义__all__变量，只能使用求和、求差功能；
（3）观察使用from xxx import *导入后的调用效果。
# 限定*的行为
__all__ = ["get_he","get_cha"]
# 求和
def get_he(a,b):
c = a + b
return c
# 求差
def get_cha(a,b):
c = a - b
return c
# 求商
def get_shang(a,b):
c = a / b
return c
# 求积
def get_ji(a,b):
c = a * b
return c
from helloutil import *
print(get_he(10,90))
print(get_cha(10,90))
# print(get_shang(10,90)) # 限定行为
# print(get_ji(10,90))总结：
（1）当要限定*仅能导入某几个功能时，可以使用
__all__变量，但使用较少；（2）
__all__变量的类型是列表。
4、制作Python包
当在一个文件夹下，创建了一个名字为__init__.py 的模块文件，那么，这个文件夹就叫做：Python包。
Python包可以将一些有联系的模块放在一起，即放到同一个文件夹下，这样更加便于管理。
需要注意：当制作完Python包后，使用包下的模块语法：
from 包名 import 模块名, xxx
总结：
（1）Python包与普通的目录区别在于：Python包中会默认有一个
__init__.py模块；（2）一般地，会在
__init__.py模块做一些初始化操作，比如初始化MySQL、初始化数据等。
七、常见的模块
1、time模块
time模块表示时间日期，常用函数：
| 函数名 | 含义 |
|---|---|
| sleep(t) | 休眠，即延迟运行，注意参数t的单位为秒(s)。 |
| time() | 返回时间戳，即当前时间秒数（与1970年1月1日午夜之间的时间差）。 |
例如，一起来完成：
（1）导入time模块；
（2）模拟出5-1的倒序，且每隔1s后输出一个数字的倒计时样式。
# 导入模块
from time import sleep, time
# 获取从1970年到当前的秒值
print(time())
# 延迟函数
while True:
sleep(1) # 程序执行到这里就会休眠一秒钟，然后醒来，继续执行
print('我爱你中国!')总结：
（1）当要延时处理时，可以快速使用time模块的sleep()函数。
2、动态抽奖案例
例如，一起来完成：
（1）使用所学知识来完成一个动态抽奖系统案例；
（2）使用文件操作、模块知识来配合完成获取学生名单；
（3）注意：学生信息来源于班级学生名单.txt。
# 1.导入模块
import random
import time
# 2.读取学生名单文件
with open("学生名单.txt","r",encoding="utf-8") as file:
# 3.获取学生名单列表
texts = file.read()
# 切割
student_lists = texts.split("\n")
# print(student_lists)
# 4.动态获取列表索引
index = random.randint(0, len(student_lists)-1)
# 5.倒序输出
i = 5
while i > 0:
print(i)
time.sleep(1)
i -= 1
# 6.学生结果
print(f"抽取结果为:{student_lists[index]}")
# 1.导入模块
import random
import time
def my_sleep():
i = 5
while i > 0:
print(i)
time.sleep(1)
i -= 1
# 2.读取学生名单文件
with open("学生名单.txt","r",encoding="utf-8") as file:
# 3.获取学生名单列表
texts = file.read()
# 切割
student_lists = texts.split("\n")
for i in range(3):
index = random.randint(0, len(student_lists) - 1)
my_sleep()
# 6.学生结果
print(f"第{i+1}个幸运学生为:{student_lists.pop(index)}")
print('抽奖结束！')标签：__,文件,进阶,Python,模块,print,import,异常 From： https://blog.csdn.net/weixin_52854743/article/details/140234912总结：
在实际应用中，若要动态获取数据，则可以直接使用随机数值去表示。