练习39
# __new__
# 在init之前，实例化对象的第一步是__new__创建了空间
# class Foo:
# def __init__(self): # 初始化方法
# print('执行了init')
# def __new__(cls, *args, **kwargs): # 构造方法
# # object.__new__(cls)
# print('执行了new')
# return object.__new__(cls)
#
# object = Foo()
# 创造一个对象 比喻成捏小人
# new 是小人捏出来了
# init 给小人穿衣服
# 设计模式
# 常用的23种
# java里出来的
# python
# 推崇设计模式 java开发
# 贬低设计模式 纯python开发
# 单例模式
# 一个类 只有一个实例的时候 单例模式
# class Foo:
# __instance = None
# def __init__(self,name,age): # 初始化方法
# self.name = name
# self.age = age
# self.lst = [name]
# def __new__(cls, *args, **kwargs): # 构造方法
# if cls.__instance is None:
# cls.__instance = object.__new__(cls)
# return cls.__instance
#
#
# obj1 = Foo('alex',20)
# obj2 = Foo('agon',22)
# print(obj1.name,obj2.name)
# print(obj1.lst,obj2.lst)
# 析构方法
# class Foo:
# def __init__(self,name,age):
# self.name = name
# self.age = age
# self.file = open('file',mode = 'w')
# def write(self):
# self.file.write('sadasd')
# def __del__(self): # 析构方法：在删除这个类创建的对象的时候，会先触发这个方法，在删除对象
# # 做一些清理工作 比如：关闭文件，关闭网络的连接，关闭数据库的连接
# self.file.close()
# print('执行del')
# f = Foo('alex',20)
# del f
# print(f)
# 其他内置方法
# len() list dict set str tuple
# print('__len__' in dir(list))
# print('__len__' in dir(set))
# print('__len__' in dir(tuple))
# print('__len__' in dir(dict))
#
# print('__len__' in dir(int))
# print('__len__' in dir(float))
# class Foo:
# def __len__(self):
# return 1
#
# obj = Foo()
# print(len(obj))
# class Class:
# def __init__(self,name,course):
# self.name = name
# self.course = course
# self.student = []
# def __len__(self):
# return len(self.student)
#
# s1 = Class('班级1','python')
# s1.student.append('wuyi')
# s1.student.append('yangyi')
# s1.student.append('wangsan')
# print(s1.student)
# print(len(s1))
# __eq__
# class Staff:
# def __init__(self,name,sex):
# self.name = name
# self.sex = sex
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# alex = Staff('alex','不详')
# alex2 = Staff('alex','不详')
# alex22 = Staff('alex2','female')
# print(alex == alex2) # alex.__eq__(alex2)
# print(alex2 == alex22)
# l1 = [1,2,3,4]
# l2 = [1,2,3,4]
# print(id(l1),id(l2))
# print(l1 == l2)
# __hash__
# class Foo():
# pass
# obj1 = Foo()
# obj2 = Foo()
# print(hash(obj1)) # 内存地址
# print(hash(obj1)) # 内存地址
# print(hash(obj1)) # 内存地址
# print(hash(obj1)) # 内存地址
# print(hash(obj1)) # 内存地址
# print(hash(obj1)) # 内存地址
# print(hash(obj2)) #
# 1. 每次执行hash值都会变化
# 2. 在一次执行的过程种对同一个值hash结果总是不变的
# 字典为什么寻址快
# dic = {'name':'alex','age':83,'sex':'不详'}
# 字典在内存中是如何存储的？
# 为什么字典的key必须是可hash
# hash算法
# 1. 对于相同的值在一次程序的运行中是不会变化的
# 2. 对于不同的值在一次程序的运行中总是不同的
# set的去重机制
# new_lst = []
# lst = [2,2,43,53,213,342]
# for i in lst:
# if i in lst:
# pass
# else:
# new_lst.append(i)
# set = {1,2,'abc',3,4,5,6,7,8,9,'bca'}
# 不能通过逐个判单值相等这件事儿来做去重工作 慢
# hash算法也不是完全靠谱
# set 去重机制
# 1. 对每一个元素进行hash计算处一个内存地址
# 2. 到这个内存地址上查看
# 如果这块内存中没有值
# 将这个元素存到对应的内存低智商
# 如果这块内存中有值
# 判断着俩个值是否相等
# 如果相等 就舍弃后面的值
# 如果不相等 就二次寻址 再找一个新的空间来存储这个值
# 员工类
# 姓名 年龄 性别 部门
# 转岗位
# 姓名 年龄变化了 性别 部门
# 100个员工
# 去掉重复的
# 员工的姓名 性别是相等的，就认为是同一个员工、
# class Staff:
# def __init__(self,name,age,sex,dep):
# self.name = name
# self.age = age
# self.sex = sex
# self.dep = dep
# def __hash__(self):
# return hash(self.name + self.sex)
# def __eq__(self, other):
# if self.name == other.name and self.sex == other.sex:
# return True
#
# name_lst = ['yuan','egon','nazha','peiqi']
# obj_lst = []
# for i in range(100):
# name = name_lst[i%4]
# obj = Staff(name,i,'男','python')
# obj_lst.append(obj)
# print(obj_lst)
# ret = set(obj_lst)
# print(ret)
# for i in ret:
# print(i.name,i.age)
# 模块
# 别人写好的功能放在一个文件里
# 内置模块：安装python解释器的时候一起装上的
# 第三方模块、扩展模块：需要自己安装
# 自定义模块：你写的py文件
# 序列化模块
# 序列
# 列表
# 元素
# 字符串 *
# bytes *
# 什么叫序列化
# 把一个数据类型转换成 字符串、bytes类型的过程就是序列化
# 为什么要把一个数据类型放在文件里？
# {'name':'何青松','age':'male'}
# 当你需要把一个数据类型存储在文件中的时候
# 当你需要把一个数据类型通过网络传输的时候
# 及其不安全的
# stu = {'name':'何青松','age':'male'}
# ret = str(stu)
# print(stu)
# print(ret)
# print([eval(ret)]) # 用户输入的、文件读入的、网络传入的
import json
# stu = {'name':'何青松','age':'male'}
# ret = json.dumps(stu) # 序列化过程
# print(stu,type(stu))
# print(ret,type(ret))
#
# d = json.loads(ret) # 反序列化的过程
# print('d-->',d,type(d))
# lst = [1,2,3,4,'aaa','bbb']
# ret = json.dumps(lst) # 序列化过程
# print(lst,type(lst))
# print(ret,type(ret))
#
# d = json.loads(ret) # 反序列化的过程
# print('d-->',d,type(d))
# json的优点
# 所有的语言都通用
# 缺点
# 只支持非常少的数据类型
# 对数据类型的约束很苛刻
# 字典的key必须是字符串，
# 支支持：数字 字符串 列表 字典
# stu = {'name':'何青松','age':'male',1:('a','b')}
# ret = json.dumps(stu) # 序列化过程
# print(stu,type(stu))
# print(ret,type(ret))
#
# d = json.loads(ret) # 反序列化的过程
# print('d-->',d,type(d))
import pickle
# stu = {'name':'何青松','age':'male',1:('a','b')}
# ret = pickle.dumps(stu)
# print(ret)
# d = pickle.loads(ret)
# print(d,type(d))
# class Course():
# def __init__(self,name,price):
# self.name = name
# self.price = price
# python = Course('python',29800)
# print(python)
# ret = pickle.dumps(python)
# print(ret)
# p = pickle.loads(ret)
# print(p.name,p.price)
# dic = {'name':'何青松','age':'male'}
# str_dic1 = json.dumps(dic,ensure_ascii=False)
# # str_dic2 = json.dumps(dic)
# # print(str_dic1)
# # print(str_dic2)
# with open('json_file',encoding='utf-8',mode = 'w') as f:
# f.write(str_dic1)
# with open('json_file','r',encoding='utf-8') as f:
# content = f.read()
# ret = json.loads(content)
# print(ret['name'])
# 方法 dump load 着俩个方法 是完全和文件打交道
# dic = {'name':'何青松','age':'male'}
# with open('json_file',encoding='utf-8',mode = 'w') as f:
# json.dump(dic,f,ensure_ascii=False)
# with open('json_file','r',encoding='utf-8') as f:
# dic = json.load(f)
# print(dic,dic['name'])
# 能不嫩多次向一个文件中dump，可以，但是不能多次load
# dic = {'name':'何青松','age':'male'}
# with open('json_file',encoding='utf-8',mode = 'w') as f:
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# with open('json_file','r',encoding='utf-8') as f:
# dic = json.load(f)
# 我有需求向文件中写入多个字典！！！
# def my_dumps(dic):
# with open('json_file.txt',encoding='utf-8',mode = 'a') as f:
# dic_str = json.dumps(dic,ensure_ascii=False)
# print(dic_str)
# f.write(dic_str+'\n')
#
# dic1 = {'name':'何青松','sex':'male'}
# dic2 = {'name':'关亮何','sex':'male'}
# dic3 = {'name':'何思浩','sex':'male'}
#
# my_dumps(dic1)
# my_dumps(dic2)
# my_dumps(dic3)
# with open('json_file.txt',encoding='utf-8',mode = 'r') as f:
# for line in f:
# dic = json.loads(line.strip())
# print(dic['name'])
# json
# 可以在所有的语言中通用
# 能够处理的数据类型非常有限
# 在网络操作者，以及多语言环境当中，要传递字典、数字、字符串、列表等简单的数据类型的时候使用
# json的字典有非常苛刻的要求：key必须是字符串，且所有的字符串都必须是用“”表示
# dumps(dic/list) dic/list --> str 序列化
# loads(str) str --> dic/list 反序列化
# dump(dic/list,f) dic/list --> 文件 序列化
# load(f) 文件 --> dic/list 反序列化 多次dump进入文件中的数据load会报错
# 参数：ensure_ascii=False 希望序列化的中文能以中文的形式被实现并且写到文件中
# data = {'username':['李华','二愣子'],'sex':'male','age':16}
# json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
# print(json_dic2)
# pickle
# class Course():
# def __init__(self,name,price):
# self.name = name
# self.price = price
# python = Course('python',29800)
# linux = Course('linux',25800)
# mysql = Course('mysql',18000)
# ret = pickle.dumps(python)
# print(ret)
# p = pickle.loads(ret)
# print(p.name,p.price)
# with open('pickle_file.txt','wb') as f:
# pickle.dump(python,f)
# with open('pickle_file.txt','rb') as f:
# course = pickle.load(f)
#
# print(course.name)
# pickle
# dump
# load
# 操作文件必须以+b打开
# 在load的时候 如果这个要被load的内容所在的类不在内存中，会报错
# pickle 支持多次dump和多次load（需要异常处理）
# pickle 能不能多次dump
# def my_dump(course):
# with open('pickle_file.txt','ab') as f:
# pickle.dump(course,f)
# my_dump(python)
# my_dump(linux)
# my_dump(mysql)
# with open('pickle_file.txt','rb') as f:
# while 1:
# try:
# content = pickle.load(f)
# print(content.name)
# except EOFError:
# break
扫一扫
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
