第十五天

第一部分 文件与路径的操作

 一、 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("产生了异常")