python基础复习 12

# 什么是序列化：数据类型转化成字符串的过程就是序列化
# 作用：为了方便存储和传输

# json   可以操作的数据类型（数字、字符串、列表、字典、元祖）
   # 通用的序列化格式
   # 只有很少的一部分数据类型能够通过json转化成字符串
       # dumps  序列化
       # loads    反序列化
       # dump  和文件有关
       # load   load 不能load多次

# pickle
    # 所有的python中的数据类型都可以转化成字符串形式
    # pickle序列化的内容只有python能理解
    # 且部分反序列化依赖代码
        # 方法和json一样
        # dump 和 load的时候 文件是rb或者wb打开的
        # 支持python所有的数据类型
        # 序列化和反序列化需要相同的环境

# shelve
    # 序列化句柄
    # 使用句柄直接操作，非常方便
        # open方法
        # open方法获取了一个文件句柄
        # 操作和字典类似



# json 提供dumps序列化方法    loads 反序列化方法
# dic = {"k1": "v1"}
# print(type(dic),dic)
# import json
# str_d = json.dumps(dic)
# print(type(str_d),str_d)
#
# dic_d = json.loads(str_d)
# print(type(dic_d),dic_d)


# dic = (1,2,3,4)
# print(type(dic),dic)
# import json
# str_d = json.dumps(dic)
# print(type(str_d),str_d)
#
# dic_d = json.loads(str_d)
# print(type(dic_d),dic_d)


# json  dump  load  (他俩是关于文件的操作)

# import json
# dic = {1: "a", 2: "b"}
# f = open('fff', 'w', encoding='utf-8')
# json.dump(dic,f)
# f.close()
# 把字典写到文件里


# import json
# f = open('fff')
# res = json.load(f)
# f.close()
# print(type(res),res)



# import json
# dic = {1: "中国", 2: "b"}
# f = open("fff","w",encoding="utf-8")
# json.dump(dic,f,ensure_ascii=False)  # 如果没有ensure_ascii=False，文件中会出现乱码，是bytes类型
# f.close()
# f = open("fff",encoding="utf-8")
# res = json.load(f)
# f.close()
# print(type(res),res)
# 注：用json中的dump与load 只能是一次性写进去，一次性读出来
# 如果想一次一次的读出来，可以用dumps与loads代码如下
# l = [{"k": "111"}, {"k2": "111"}, {"k3": "111"}]
# f = open('file', 'w')
# import json
# for dic in l:
#     str_dic = json.dumps(dic)
#     f.write(str_dic+'\n')
# f.close()
# f = open('file')
# import json
# l = []
# for line in f:
#     dic = json.loads(line.strip())
#     l.append(dic)
# f.close()
# print(l)


# pickle可以序列化任何数据类型
# pickle 也提供四种方法  dumps loads  dump load
# pickle 支持分次load  json不直接支持
# import pickle
# dic = {"k1": "v1", "k2": "v2", "k3": "v3"}
# str_dic = pickle.dumps(dic)
# print(str_dic)  # 一串二进制内容
#
# dic2 = pickle.loads(str_dic)
# print(dic2)



# 文件就是一个模块
# 模块的命名必须符合命名规则
# 先导入内置模块  再导入扩展的 例如Django 再倒入自定义的


异常和错误
# 程序中难免出现错误，而错误分成两种
#    1 语法错误（这种错误，跟本过不了python解释器的语法检测，必须在程序执行前就改正）
#    2 逻辑错误

# 如果不写异常处理语句，输入字母的话，会报错（出红）
# try:
#     ret = int(input('number >>>'))
#     print(ret*'*')
# except ValueError:
#     print("请输入数字")

# 使用try和except就能处理异常
    # try是我们需要处理的代码
    # except 后面跟一个错误类型  当代码发生错误且错误类型符合
    #    的时候，就会执行except中的代码
    #    可以有多个except

# 万能异常
# try:
#     [][3]
#     ret = int(input("number>>>"))
#     print(ret*"*")
# except Exception:
#     print("列表输入有误")





# 面向对象
# 人狗大战
# def Person(name,blood,aggr,sex):
#     person = {
#         "name": name,
#         "blood": blood,
#         "aggr": aggr,  # 攻击力
#         "sex": sex,
#     }
#     def attack(dog):
#         dog["blood"] -= person["aggr"]  # 人打狗，狗掉血，人的攻击力多少，就掉多少血
#         print("%s被打了，掉了%s的血" % (dog["name"], person["aggr"]))
#     person["attack"] = attack
#     return person
#
#
# def Dog(name,blood,aggr,kind):
#     dog = {
#         "name": name,
#         "blood": blood,  # 血量
#         "aggr": aggr,  # 攻击力
#         "kind": kind,  # 品种
#     }
#     def bite(person):
#         person["blood"] -= dog["aggr"]
#         print("%s被打了，掉了%s滴血" % (person["name"], dog["aggr"]))
#     dog["bite"] = bite
#     return dog
#
#
# laoban = Dog("老板",1000,3,"不详")
# alex = Person("狗蛋儿",100,2,"不详")
# nezha = Person("哪吒",200,2,"不详")

# # print(laoban)
# # laoban["bite"](alex)
#
# alex["attack"](laoban)




# class Person:
#     country = "China"   # 创造了一个只要是这个类就一定有的属性
                                     # 类属性 也叫静态属性
#     def __init__(self,*args):  # 初始化方法 self 是对象，是一个必须传的参数
#         print(args)
#
# alex = Person("狗蛋哥",100,1,"不详")



class Person:
    def __init__(self,*args):
        # print(self.__dict__)
        self.name = args[0]
        self.hp = args[1]
        self.sex = args[2]
        self.aggr = args[3]
        # print(self.__dict__)
        # print(id(self))
    def walk(self):     # 方法，一般情况下必须传self参数，且必须写在第一个，后面还可传其他参数
        print("走走走")
#
alex = Person("狗蛋儿", 100, 1, "不详")  # 类名还可以实例化对象，alex就是对象  #这个过程就是实例化
print(alex.__dict__)
alex.name = '精心'
# alex.__dict__["name"] = "太白"
print(alex.__dict__)
print(alex.name)
# print(alex)
# print(Person.__dict__)  # 不管类还是对象，都可以调用__dict__这个属性

# 对象 = 类名（）
# 过程：
   # 类名（） 首先会创造出一个对象，创建了一个self变量
   # 调用init方法，类名括号里的参数会被这里接受
   # 执行init方法
   # 返回self
# 对象能做的事
   # 查看属性
   # 调用方法
   # __dict__ 对于对象的增删改查操作都可以通过字典的语法进行
# 类名能做的事
  # 实例化
  # 调用方法：只不过要自己传递self参数
  # 调用类中的属性
  # __dict__对于类中的名字只能看  不能操作

# 注：本文是根据老男孩课程内容整理而成的，本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。