第一部分 文件与路径的操作
一、 os模块
import os
1. 创建目录mkdir:条件，父目录必须存在，创建的目录必须不存在
# 参数创建的路径
os.mkdir("c:/abc/def")
2. makedirs创建路径，如果父路径不存在，也不会报错，会同时创建
os.makedirs("c:/abc/def/ghi",exist_ok=True)
# 有exist参数，默认值时false,存在会报错，如果改成True，存在也不会报错
3. rmdir删除空目录，如果不存在，会报错
os.rmdir("c:/abc/def/ghi")
4. removedirs删除空目录，删除之后，还会看父目录是不是空目录，如果也是空，也删除，直到不为空为止
os.removedirs("c:/abc/def/ghi")
5. remove删除文件，不存在会报错
os.remove("c:/a.txt")
6. rename 重命名文件和文件夹（路径）:注意必须是同一个目录下
os.rename("c:/abc/def/ghi/a.txt","c:/abc/def/ghi/b.txt")
7. renames 重命名文件，但是可以应用到不同路径下。
# 相当于把原来的路径下内容删除，在新的路径下，新创建一个
# 如果父目录中文件移动后，成了空目录，会被直接删除，一直删除到非空为止
# os.renames("c:/abc/def/ghi/a.txt","c:/abc2/b_new.txt")
# 注意：目标路径一定要加扩展名，否则会被认为是文件夹
# os.renames("c:/abc/def/ghi/b.txt","c:/abc2/b_new")
# 8. getcwd() current work directory当前工作目录
print(os.getcwd())
9. os.walk能够遍历路径下的文件
# os.walk(path)
# 返回值得到一个元组(dirpath)
# dirpath：字符串，代表目录的路径
# dirnames: list，包含dirpath下的所有子目录的名字
# filenames：list,包含非目录（文件）的名字
current_path=os.getcwd()
print(current_path)
t=os.walk(current_path)
print(t)
for roots,dirs,files in t:
print(roots)
print(dirs)
print(files)
print(os.path)
for fn in files:
fp_abspath=os.path.join(roots,fn)
print(fp_abspath)
二、 os.path
import os.path
1. abspath
# 当前文件的绝对路径
print(os.path.abspath("."))
2. basename 路径中最后的部分，一般以/为分隔符
print(os.path.basename("c:/abc/def/ghi/b.txt"))
print(os.path.basename("c:/abc/def/ghi"))
3. commonpath 返回多个路径中，最长的公共路径
print(os.path.commonpath(["c:/abc/def/ghi","c:a/abc/aaa","c:/abc/bbb"]))
4. exists判断目录是否存在
print(os.path.exists("c:/abc/def/ghi/aa"))
5. getatime 文件或者目录的最后访问时间
print(os.path.getatime("c:/abc2/a.txt"))
6. getmtime 文件或者目录的最后修改时间
print(os.path.getmtime("c:abc2/a.txt"))
7. getsize 获得文件的大小，以字节为单位
print(os.path.getsize("c:abc2/a.txt"))
8. isdir isfile 判断路径是否是一个存在的文件或者目录
print(os.path.isdir("c:/abc2"))
print(os.path.isfile("c:/abc2/a.txt"))
9. join 拼接路径
print(os.path.join("abc","def","ghi"))
# 注意，传入了绝对路径，在绝对路径之前的都去掉了
# 如果最后一个字符是"",会生成一个/
# 如果""在中间的位置，会忽略
print(os.path.join("yyy","c:/","","abc","def","ghi"))
10. split 拆路径
# 拆成两部分，一部分是基础路径basename，还有一部分是dirname所在的目录，元组
print(os.path.split("c:/abc/def/ghi"))
三、 shutil模块
1. copy(源文件所在的路径，目标路径)
import shutil
# 目标路径必须存在，如果没有文件名字，那么会把源文件名字认为是拷贝之后的文件名
# 注意的是，目标路径要么不写名字（路径以/结尾），要么就写正确的文件名字。
# 否则，拷贝后的文件名会以/后面的部分为文件名,而且没有扩展名
# 不能拷贝mtime和atime
shutil.copy("c:/abc2/a.txt","c:abc/2")
shutil.copy("c:/abc2/a.txt","c:/abc/")
2. copy2是对copy的升级，会把文件的源信息都拷贝过来
# shutil.copy2("c:/abc2/a.txt","c:/abc/")
3. copytree 拷贝，会连同目录，子目录下文件都拷贝
# 第一个参数：源路径
# 第二个参数：目标路径（要求目标路径不能存在，如果存在会报错）
# 函数返回目标路径
print(shutil.copytree("c:/abc2","c:def"))
4. rmtree 删除目标路径，包括下面的子目录和文件都会删除
shutil.rmtree("c:abc2")
5.move 连同当前目录以及目录下的子目录和文件都移动到目标
shutil.move("c:/abc","d:abc")
第二部分 序列化
"""
序列化：
读 写 保存数据，涉及到不同类型的文件。
csvjsonpickle
"""
一 、csv
1. csv comma separted values 文本格式文件，各个元素之间使用","分隔，不是必须
# 扩展名.csv
"""
姓名 年龄 小组
张三，15，A组
李四，14，B组
王五，16，C组
"""
import csv
with open("c:/test.csv","wt",newline="") as f:
write=csv.writer(f)
# 一次写入一行
# newline为了在excel显示没有换行
write.writerow(["张三",15,"A组"])
write.writerow(["李四",14,"B组"])
write.writerow(["王五",16,"C组"])
write.writerows([["张三1",15,"A组"],["李四2",14,"B组"],["王五3",16,"C组"]])
二、json
1. json javascript object notation 数据交换格式
# 键和值 之间使用：分隔，元素和元素之间使用，
# 关于json的数据类型
"""
对象类型：使用{}
数组类型：[]
字符串类型：""
布尔类型：true和false
数值类型：5,2.8
"""
"""
{
"bg":"green",
"title":{
"data":["data1","data2","data3","data4"],
"align":"左对齐"
}
}
"""
# python跟json之间数据交换特别容易，因为结构跟在python的字典几乎一样
d={
"bg":"green",
"title":{
"data":["data1","data2","data3","data4"],
"align":"左对齐"
}
}
# python和json转换
# 1. python的字典转成json的数据（扩展名就是json）
# dump方法
import json
with open("c:/test.json","wt") as f:
# 第一个参数：要写入的数据，就是python的字典
# 第二个参数：文件对象，json文件
# 在json写入数据时，默认显示的是unicode字符集----对应ascii编码
# 需要将ascii是否启用标志=False
json.dump(d,f,ensure_ascii=False)
# 将json文件的数据，转成python的字典
# load方法：
with open("c:/test.json","rt") as f:
d1=json.load(f)
print(type(d1))
print(d1)
序列化和反序列化。
"""
序列化：把对象转换成字符串或者字节的形式
反序列化：就是把序列化的字符串或者字节转换成（恢复成）对象
"""
json.dumps()实现序列化,返回值就是序列化的结果（字符串或者字节）
d={
"bg":"green",
"title":{
"data":["data1","data2","data3","data4"],
"align":"左对齐"
}
}
s=json.dumps(d,ensure_ascii=False)
print(s)
print(type(s))
json.loads()进行反序列化，返回值就是对象。把字符串恢复成对象（例如字典类）
d2=json.loads(s)
print(d2)
print(type(d2))
# python的类型和json的数据类型之间的映射关系
d={
"布尔类型":True,
"空值类型":None,
"浮点类型":1.5,
"整数类型":1,
"字符串类型":"abc",
"数组类型":[1,2,3],
"对象类型":{"a":1,"b":2}
}
datastr=json.dumps(d,ensure_ascii=False)
print(datastr)
d2=json.loads(datastr)
print(d2)
# 其他类型的序列化
# 自己写一个类，创建一个对象，能不能直接序列化
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
p=Person("张三",15)
json.dumps(p)
# 直接将自定义类型的对象，序列化，不可以，只能自己实现类进行格式化
# 实现encode，继承json.JSONEncoder 只有覆盖default方法
class PersonEncoder(json.JSONEncoder):
def default(self,o):
# o 就是要序列化的对象
if isinstance(o,Person):
# return {"name":o.name,"age":o.age,"自定义key":"自定义的值"}
return "小老鼠上灯台"
else:
return super().default()
# 对自定义对象序列化时，cls=指定处理当前对象序列化类
personstr=json.dumps(p,cls=PersonEncoder,ensure_ascii=False)
print(personstr)
三、 pickle
# 适合python的序列化类型
import pickle
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
p=Person("张三",15)
print(pickle.dumps(p))
with open("c:/person.pickle","wb") as f:
pickle.dump(p,f)
# 自己定义一个类Animal类，name,weight,属性，进行序列化，写到文件里
第三部分 上下文管理器
"""
上下文管理器
with : with语句实际上，后面跟随的表达式，会返回一个上下文管理器，
在上下文管理器中会定义相关的方法，当with开始执行或者退出，会自动调用一些魔法方法
可以看成是：上下文管理器为with提供了一个执行环境。
"""
# 上下文管理器中，需要定义__enter__方法，__exit__方法。
# __enter__在进入with的时候，执行
# __exit__方法在退出的时候执行，清理资源的行为
# 自定义上下文管理器
class MyContext:
def __enter__(self):
print("进入了with语句")
return "success"
def __exit__(self, exc_type, exc_val, exc_tb):
print(exc_type)
print(exc_val)
print(exc_tb)
print("离开了with语句")
# f 是__enter__ 方法的返回值
with MyContext() as f:
print(f)
# raise Exception("with中发生了异常")
print("正在执行with")
print("已经离开了")
# 上下文管理器 __exit__ 中相关参数，都是用来处理异常的。
# with语句体没有发生异常的时候，参数都是None
# exc_type,发生异常的类型
# exc_val, 产生异常的对象，包含信息
# exc_tb，堆栈轨迹对象
# 上下文管理器装饰器
# 用来修饰一个生成器，可以把生成器装饰成上下文管理器
from contextlib import contextmanager
@contextmanager
def gen():
print("abc")
try:
yield "产出一个值"
except:
print("发生了Exception异常")
print("def")
# 使用上下文管理器装饰器装饰的生成器，变成了上下文管理器，以yield为分界点
# yield 之前的内容都可以看成是__enter__方法,yield的产出值就是enter方法的返回值，也就是f
# yield 之后的内容都可以看成是__exit__方法
with gen() as f:
# print(f)
raise Exception("产生了异常")