# ========================= 构造方法 ， 析构方法， 初始化
# 构造方法 创建一个对象的
# 初始化方法 __init__ 给已经创建出来的对象添加属性
# 析构方法 删除一个对象的时候调用的方法
# import time
# class A:
# def __init__(self):
# self.f = open('userinfo','a')
# def consume(self):
# pass
# def __del__(self):
# '''在删除一个对象之前做一些收尾工作'''
# self.f.close()
# print('删除一个对象的时候调用我')
#
# a = A()
# time.sleep(1)
# del a
# # 删除一个对象的时候,如果内部存在__del__方法,
# # 那么在删除一个对象之前先执行__del__方法中的代码
# print(a)
# ========================= __new__ 构造方法 =====================
# new一个对象
# object.__new__()
# class A:
# def __init__(self):
# print('执行init方法了')
# def __new__(cls):
# print('执行new方法了')
# return object.__new__(cls) # 创造对象,将对象返回
#
# a = A()
# print(type(a))
# print(type(A))
# 先执行__new__方法 创造出一个对象
# 然后把创造出来的对象传递给__init__方法
# 会把self自动的返回,被a接收
# 元类
# 有一个元类 在创建类
# type() 所有直接用class创建出来的类的元类都是type
# class 类名(B,metaclass=type = 元类名)
# class 类名(B,metaclass=type) # 默认
# 元类 创造 类 所以所有的类的type都是它的元类,默认是type
# 类 创造 对象 具体创造对象的方法 __new__方法,所有的对象的type都是它对应的类
# python中 一切皆对象
# 变量 都有它属于的数据类型
# 设计模式
# 单例模式
# 一个类 可以被多次实例化 但是同一时间在python的内存中,只能有一个实例
# class A:
# _instance = None
# def __init__(self,name):
# '''给娃穿衣服'''
# self.name = name
# def __new__(cls, *args, **kwargs):
# '''生娃的过程'''
# if not A._instance:
# A._instance = object.__new__(cls)
# return A._instance
# a1 = A('alex') # 第一次实例化的时候创造一个实例
# print(a1.name)
# a2 = A('egon')
# print(a1.name,a2.name) # 'alex' 'alex'
# class A:
# def __init__(self,name):
# '''给娃穿衣服'''
# self.name = name
# def __new__(cls, *args, **kwargs):
# '''生娃的过程'''
# if not hasattr(A,'_instance'):
# A._instance = object.__new__(cls)
# return A._instance
# a1 = A('alex') # 第一次实例化的时候创造一个实例
# print(a1.name)
# a2 = A('egon')
# print(a1.name,a2.name) # 'alex' 'alex'
# class A:
# name = 'Alex'
# @classmethod
# def func(cls):
# pass
# A.name = 'Egon'
### = item 系列
# class A:
# def __init__(self,name):
# self.name = name
# self.age = 81
# def __getitem__(self, item): #a["name"] 就是自动调用了getitem 方法
# return self.__dict__[item]
# def __setitem__(self, key, value): # 增加一个属性
# self.__dict__[key] = value
# def __delitem__(self, key): # 删除一个属性
# del self.__dict__[key]
# a = A('alex')
# print(a['name']) # 对应了类中一个方法的语法
# a.name
# print(a['age']) # 对应了类中一个方法的语法
# a.age
# 增加 和 修改一个属性
# a['sex'] = '不详'
# # a.sex = '不详'
# print(a.__dict__)
# # print(a.sex)
# # print(a['sex'])
# a['sex'] = '女'
# print(a.__dict__)
# del a['sex']
# print(a.__dict__)
# -- call
# class A:
# def __init__(self,):
# print("s")
# def __call__(self,a):
# print('执行我了',a,)
# def call(self,a):
# print('执行我了',a,)
# a = A()# 执行
# a('aaa') # 执行__call__
# a.call('aaa')
# ========== __hash__
# hash
# 不可变的数据类型都可以被hash
# dic = {"name":"alex"}
# class A:
# def __hash__(self):
# return object.__hash__(self)
# a = A()
# b = A()
# print(hash(dic["name"])) # object.__hash__()
# print(hash(a)) # object.__hash__()
# print(hash(a)) # object.__hash__()
# print(hash(a)) # object.__hash__()
# print(hash(a)) # object.__hash__()
# print(hash(a)) # object.__hash__()
# print(hash(a)) # object.__hash__()
# print(hash(b)) # object.__hash__()
# dict的key set的元素
# dic key --> value
# dic[key] = value
# hash(obj)函数,obj对象对应的类必然内部实现了__hash__方法
# hash的结果就是__hash__方法的返回值
# 且在一次成的执行过程中是不会发生变化的
# 且要想作为字典的key或者作为集合的元素,这个对象对应的类必须实现__hash__方法
# 面试题 ###
# 金融公司面试题
# 有一个类,对应这个类产生了100个对象
# 每个对象有三个属性 : 姓名 年龄 性别
# 请对这一百个对象进行去重,如果姓名和性别相同,即便年龄不同也是相同的对象
# 问最简便的方法?
# class Person:
# def __init__(self,name,age,sex):
# self.name = name
# self.age = age
# self.sex = sex
# def __hash__(self):
# return hash('%s%s'%(self.name,self.sex))
# def __eq__(self, other):
# if self.name == other.name and
# self.sex == other.sex:
# return True
# p_lst = []
# for i in range(100):
# p_lst.append(Person('egon',i,'male'))
# p_lst.append(Person('alex',i,'male'))
# p_lst.append(Person('yuan',i,'male'))
# print(p_lst)
# print(set(p_lst)) # 报错不可hash 完成了__hash__
# class Person:
# def __init__(self,name,age,sex):
# self.name = name
# self.age = age
# self.sex = sex
# def __eq__(self, other):
# if self.name == other.name and
# self.sex == other.sex:
# return True
# def __hash__(self):
# return hash("%s%s"%(self.name,self.sex))
# p_lst = []
# for i in range(100):
# p_lst.append(Person("alex",i,"male"))
# print(set(p_lst))
# hash是否相等 __hash__
# 值是否相等 __eq__
# 收获1
# 对于一些python当中已经存在的内置函数 内置数据类型 内置模块中的方法
# 都有可能依赖于类中的内置方法
# 收获2
# set方法依赖集合中元素对象的__hash__ __eq__
# = 纸牌实例
# 数据结构与算法 python 数据结构
# python核心编程第二三版 基础
# 流畅的python 进阶
# from collections import namedtuple
# Card = namedtuple('Card',['rank','suit'])
# # card1 = Card(1,'红桃')
# class FranchDeck:
# ranks = [str(n) for n in range(2,11)] + list('JQKA')
# suits = ['红心','方板','梅花','黑桃']
# def __init__(self):
# self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
# for suit in FranchDeck.suits]
# def __len__(self):
# return len(self._cards)
#
# def __getitem__(self, item):
# return self._cards[item]
#
# def __setitem__(self, key, value):
# self._cards[key] = value
# deck = FranchDeck()
# print('**',deck[:])
# print(deck.__dict__)
# from random import choice
# print(choice(deck)) # deck对象对应的类中的getitem方法和len方法
# from random import shuffle
# shuffle(deck)
# print(deck[:])