Python入门课程系列：

Python学习 day1：认识Python
Python学习 day2：判断语句与循环控制
Python学习 day3：高级数据类型
Python学习 day4：函数基础
Python学习 day5：函数
Python学习 day6：内置函数
Python学习 day7：面向对象基础·上
Python学习 day8：面向对象基础·中
Python学习 day9：面向对象基础·下
Python学习 day10：飞机大战游戏

导入

Python文件操作和模块

文件操作是很常见的功能，python也支持文件操作。python自带文件的基本操作方法，也借助os等模块更加方便快捷的进行文件操作。本节将详细讲解模块、常用模块、以及怎样制作、发布和安装模块。

目录：

文件打开与关闭

文件读写

应用：文件备份脚本

文件定位

模块介绍

os模块操作文件

模块的制作、发布、安装

学习目标：

通过使用文件的打开关闭、读写等，完成文件备份脚本（重点）

通过文件定位的相关方法，完成精确控制文件的读写

使用os模块操作文件，提高效率（重点）

通过模块的制作、发布、安装，进一步明白模块的意义

1. 文件打开关闭

文件操作一般步骤：

打开文件
读/写文件
保存文件
关闭文件

在python中打开文件使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
语法格式：open('文件名称','打开模式') [文件名称依赖于完整路径]
示例：open('test.txt','w')

open('./Test.txt','w',encoding='utf-8') #打开/创建文件 w不是接收是覆盖，每次都创建一个新文件
#默认的编码是gbk 也就是中文编码
#要养成打开文件时指定编码类型的习惯,最好使用utf-8
fobj=open('./Test.txt','w',encoding='utf-8') #使用一个变量去接收
#开始操作 读/写操作
fobj.write('在苍茫的大海上')
fobj.write('狂风卷积着乌云')
fobj.close() #保存加关闭
#如果再次运行fobj=open('./Test.txt','w')，原来写入的内容将不复存在

#以二进制的形式去写数据
fobj=open('./Test1.txt','wb') #str ==> byte
fobj.write('在苍茫的大海上'.encode('utf-8')) #编码也可以用参数指定
fobj.close()

fobj=open('./Test.txt','a',encoding='utf-8') #用于追加数据
fobj.write('乌云和大海之间\n') #\n表示换行
fobj.close()

文件打开模式：（a和w较为常用）

打开模式	模式说明
r	以只读方式打开文件，文件的指针会放在文件的开头，这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖，如过不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读。文件的指针会放在文件的开头，这是默认模式。
wb	以二进制格式打开一个文件用于只写。如果该文件已存在则将其覆盖，如过不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写，文件的指针会放在文件的开头。
w+	打开一个文件用于读写，如果该文件已存在则将其覆盖，如过不存在，创建新文件。
a+	打开一个文件用于读写，如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖，如过不存在，创建新文件。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

2. 文件读写

读取文件read()，将文件的内容全部读取出来。
读取指定字符个数 read(num)传入一个数字做参数，表示读取指定字符个数。
readlines()按行读取，一次性读取所有内容，返回一个列表，每一行内容作为一个元素。

f=open('./Test.txt','r')
f.read() #一次性将文件内容全部取出
print(f.read())
f.close() #关闭文件

f=open('./Test.txt','r')
content=f.read(2) #读取2个字符
print(content)
content=f.read() #第二次读取将从第一次读取的位置继续读取
print(content)
f.close() #关闭文件

f=open('./Test.txt','w')
#写入多行hello world
f.write('hello world\nhello world\nhello world\nhello world\nhello world\nhello world\n')
f.close
f=open('./Test.txt','r')
content=f.readlines() #一次性读取所有内容，返回一个列表，列表元素为每一行内容
print(content)
f.close()

f=open('./Test.txt','w')
f.write('在苍茫的大海上')
f.close
f=open('Test.txt','rb')
data=f.read()
print(data)
print(data.decode('utf-8'))
#b'\xe5\x9c\xa8\xe8\x8b\x8d\xe8\x8c\xab\xe7\x9a\x84\xe5\xa4\xa7\xe6\xb5\xb7\xe4\xb8\x8a'
f.close()
#在苍茫的大海上

with上下文管理：
with语句，不管在处理文件过程中是否发生异常，都能保证with语句执行完毕后，关闭打开的文件句柄。
优点：自动释放打开关联的对象

def main():
    with open('./Test.txt','r') as f:
        content=f.read()
        print(content)
main()

小结：
文件读写的几种操作方式

read： r r+ rb rb+
r r+：只读，适用于普通场景读取
rb rb+：适用于文件、图片、视频、音频这样的文件读取
write：w w+ wb wb+ a a+ ab
w wb+ w+：每次都会去创建文件
二进制读写的时候，要注意编码问题。默认情况下，写入文件的编码是gbk。
a a+ ab ab+：在原有文件的基础上【文件指针的末尾】去追加，并不会每次都创建新的文件

3. 应用：文件备份脚本

案例1：利用脚本完成自动备份，要求用户输入文件名称，完成自动备份

#文件的备份
def copyFile():
    # 接收用户输入的文件名
    old_file=input('请输入要备份的文件名')
    file_list=old_file.split('.')
    #构造新的文件名，加上备份的后缀
    new_file=file_list[0]+'_备份.'+file_list[1]
    old_f=open(old_file,'r') #打开需要备份的文件
    new_f=open(new_file,'w') #以写的模式打开新文件，不存在则创建
    content=old_f.read() #将内容读取出来
    new_f.write(content) #将读取的内容写入到备份文件
    old_f.close()
    new_f.close()
    pass
copyFile()

案例2：如果处理超大文件，一次将全部内容读取出来显然是不合适的，在案例1的基础上对代码进行改进，让它备份大文件也不会导致内存被占满
⚠️如下代码可能存在问题，不会创建多个新备份

#文件的备份
def copyBigFile():
    old_file=input('请输入要备份的文件名')
    file_list=old_file.split('.')
    new_file=file_list[0]+'_备份.'+file_list[1]
    try:
        #监视要处理的逻辑
        with open(old_file,'r') as old_f,open(new_file,'w')as new_f:
            while Ture:
                content=old_f.read(1024) #一次读取1024字符
                new_f.write(content)
                if len(content)<1024:
                    break
    except Exception as msg:
        print(msg)
    pass
copyFile()

4. 文件定位

tell()
文件定位，指的是当前文件指针读取到的位置，光标位置。在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取。

f=open('Test.txt','r')
content=f.read(3)
cur=f.tell()
#utf-8格式的中文，一个字符占3个字节，gbk是2字节
print(content)
print(cur)
#9
content=f.read(2)
cur=f.tell()
print(cur)
#15

truncate() 可以对源文件进行截取操作

fobjA=open('Test.txt','r+')
fobjA.truncate(15) #保留前15个字节的字符
print(fobjA.read())
fobjA.close()

seek()
在操作文件的过程，如果需要定位到其他位置进行操作，可以使用seek()。
seek(offset,from)有两个参数，offset：偏移量单位字节，负数是往回偏移，正数是往前偏移，from位置：0表示文件开头，1表示当前位置，2表示文件末尾。

用r这种模式打开文件时，在文本文件中，如果没有使用二进制的选项打开文件(rb)，则只允许从文本的开头计算相对位置，从文件尾部或者当前位置计算时，就会引发异常。

f=open('Test.txt','rb') #以二进制只读模式打开文件
content=f.read() #自动定位在结尾
print(content)
f.seek(-2,1) #在当前位置往回偏移2个字符
content=f.read(3) #读取3个字符
print(content)

f.seek(-5,2) #定位到文章结尾，往回偏移5个字节
content=f.read(3)
print(content)

f.seek(5,0) #定位到文章开头，偏移5个字节
content=f.read(3)
print(content)

5. 模块介绍

Python有强大的第三方库，有很多常用功能Python提供自带的内置模块。简单地讲模块就是封装了一堆函数的py文件，就像是一个工具包，要用到里面的工具，得先将工具包拿过来。模块也是一样，在程序中需要用到模块得先将模块导入。

import导入模块的方法：

在Python中使用import关键字导入模块。比如我们导入一个时间模块time，获取当时时间。模块导入一般放在文件最前面。
import首次导入模块的时候，会发生如下3步操作：
1.打开模块文件（按住command可以查看）
2.执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
3.在程序中会有一个模块【可以取别名】的名称指向模块的名称空间去

import time #按住command可以查看time模块的py文件
print(time.ctime()) #调用模块中的函数

调用模块的方法：
格式：模块名.函数名
这样调用可以防止不同模块中有同名方法导致错误。

搜索路径：
（1）当解释器遇到import关键字，如果模块在当前目录就会被直接导入。
（2）如果当前目录没有，到环境变量中搜索，可以用sys模块中的path变量查看所有路径（打开终端，调用python3，输入import sys，在输入sys.path来查看）
（3）如果都找不到，搜索默认路径。（linux系统默认的路径一般为/usr/local/lib/python）

导入模块时会优先搜索当前目录下是否有这个名字的模块，所以在模块命名的时候不要与系统中的模块有重名。
第三方模块安装位置，在python安装目录下的lib/site-packages/目录下。

import...as：

为模块取别名，便于调用和记忆

import time as tm
print(tm.ctime())

from...import导入模块的方法：

一个模块可能会有很多函数，如果只想导入其中几个函数，可以使用from xx import xx方式导入。例如：只想导入time模块中的ctime和time两个方法，可以按如下操作：

from time import ctime,time
print(ctime()) #不需要再加前缀
print(time())

（注意：使用from导入时，如果函数名相同，后面导入的会覆盖前面导入的。）

把模块中所有函数一次性全部导入的语法格式：from xxx import*
from...import首次导入模块的时候，会发生如下3步操作：
1.以模块为准创造一个模块的名称空间
2.执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
3.在当前执行文件的名称空间中拿到一个名字，该名字直接指向模块中的某一个名字。意味着不用加任何前缀，可以直接使用。

from...import优点：不用加前缀，代码更加简洁
from...import缺点：容易与当前执行文件中名称空间中的名字冲突
inport和from...import相同点：都会执行模块对应的文件，也都会产生模块的名称空间。两者在调用功能时都需要转到定义时寻找作用域关系
inport和from...import不同点：from...import不需要加前缀

6. os模块操作文件

对文件进行重命名、删除等一些操作，在python中可以利用os模块。（os模块仅提供一些系统级别的操作命令。）

方法	解释
os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")	改变当前脚本工作目录；相当于shell下cd
os.curdir	返回当前目录: ('.')
os.pardir	获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')	可生成多层递归目录
os.removedirs('dirname1')	若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')	生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')	删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')	列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()	删除一个文件
os.rename("oldname","newname")	重命名文件/目录
os.stat('path/filename')	获取文件/目录信息
os.sep	输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep	输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
os.pathsep	输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name	输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")	运行shell命令，直接显示
os.environ	获取系统环境变量
os.path.abspath(path)	返回path规范化的绝对路径
os.path.split(path)	将path分割成目录和文件名二元组返回
os.path.dirname(path)	返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)	返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)	如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)	如果path是绝对路径，返回True
os.path.isfile(path)	如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)	如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])	将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)	返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间

常用方法：
首先import os

修改文件名：
os.rename('路径/需要修改的文件名','路径/新的文件名')
删除文件：
os.remove('路径/待删除的文件名') #前提是文件存在
创建文件夹：
os.mkdir('路径/文件夹名称') #不允许创建多级目录
os.makedirs('路径/文件夹名称/文件夹名称') #允许创建多级目录
删除文件夹：
os.rmdir('路径/待删除的文件夹名称') #只能删除空目录
import shutil
shutil.rmtree('路径/待删除目录/待删除目录') #删除非空目录
获取当前目录：
os.getcwd()
切换目录：
os.chdir('路径')
路径拼接：
path = os.path.join(path1[,path2[,...]])
读取目录列表
os.listdir('目录') #只能得到一级目录，返回列表
os.scandir('目录') #返回迭代器对象
os.scandir搭配with使用效果更好（with是一个上下文管理器，在把资源遍历完之后会自动释放）
with os.scandir('目录') as entries:
for entry in entries:
print(entry.name)

7. 模块的制作、发布、安装

模块的定义：在python当中，一个.py文件就是一个模块。
作用：模块可以使我们有逻辑的组织我们的py代码。以库的形式去封装功能，可以非常方便的调用。
注意：不同的模块也以定义相同的变量名，但每个模块中的变量名作用域只在本模块中。
模块分类：内置模块自定义模块。第三方模块

模块的制作
Python文件都可以作为一个模块，模块的名字就是文件的名字。比如创建一个test.py文件，文件中创建一个add函数，test.py就是一个模块。

注意点：

__ name __ ():

def add(x,y): 用于模块结尾的测试
    return x+y
#❗️测试
if __name__=='__main__': # __name__ 函数在做书写模块做测试时使用，使得测试结果只在本模块运行，在其他模块不运行。
    res=add(2,3)
    print('测试模块:add结果是%s'%res)
    print('模块__name__变量=%s'%__name__) #在本测试模块返回模块__name__变量=__main__，在其他模块返回模块__name__变量=MethodAdd

__ all __ ()：如果在一个文件中存在__ all __ ()变量，意味着只有在变量中的元素可以被from...import或import*这两种方法调用。没有在__ all __ ()变量中声明的元素则不能被上述两种方法调用。__ all __ ()变量对元素的限制对import方法不起作用。

模块的发布
平时使用的模块是其他开发者发布出来的，需要安装后调用。
模块发布步骤
1）将写好的包放在一个目录下
2）在该目录下创建一个setup.py文件，文件里写入如下代码

from distutils.core import setup
# name 模块名称
# version 版本号
# description 描述
# author 作者
# py_modules 要发布的内容
setup(name='my_module',version='1.0',description='my module',author='hui',py_modules=['test1.A','test1.B','test2.C','test4.D'])

3）创建模块
在终端，进入目录。执行：python setup.py build
4）生成压缩包
python setup.py sdist
5）生成的dist文件夹中的压缩包就可以发布给别人使用了

模块的安装
1）将压缩包复制到桌面解压
tar -zxvf 压缩包名字
解压后会生成一个文件夹
2）进入文件夹
3）执行命令安装python setup.py install
4）查看是否安装成功
在python的安装目录下的site-package目录下

总结：

文件打开关闭
文件操作一般步骤：文件打开、文件关闭、with上下文管理
文件读写
写文件、读文件
应用：文件备份脚本
文件定位：tell() seek()
模块介绍
import导入模块
搜索路径
from...import导入模块方法
as给模块取别名
os模块操作文件
概述、常用方法
time、datetime模块
模块的制作、发布、安装

课后作业·问答题

文件打开方式有哪些？往文件里追加内容是哪个模式
怎么查看python环境变量

Python学习 day11-2021.3.9（文件操作与模块）

导入