构造方法：在面向对象中，创建一个对象的过程（new一个对象）
#new一个对象 # object.__new__() # class A: # def __init__(self): # print(‘执行inint方法了‘) # def __new__(cls): # print(‘执行new方法‘) # return object.__new__(cls) #创造对象并返回 # a=A() #先执行——new——方法。创造出一个对象 #然后把创造出来的对象传递给init方法 #会吧self自动返回，被a接收
元类 创造 类 ：所以所有的类的type都是它的元类，默认是type
类 创造 对象：具体创造对象的方法__new__方法，所有的对象的type都是他对应的类
class A:#创建一个类 def __init__(self):pass def __new__(cls, *args, **kwargs):#创建一个对象的过程 return object.__new__(cls) a=A() print(type(a)) #》》<class ‘__main__.A‘> print(type(A)) #》》<class ‘type‘>
析构方法：删除一个对象的时候调用的方法就是析构方法
import time class A: def __init__(self): self.f=open(‘log‘) def __del__(self): self.f.close()#在删除之前收尾，关闭文件 print(‘删除一个对象的时候调用‘) a=A() time.sleep(1) del a #删除一个对象的时候。如果内部存在——del——方法 #那么在删除一个对象之前。先执行——del——方法
单例模式：一个类可以被多次实例化，但是同一时间在Python的内存中，只能有一个实例
运行步骤：
#操作__new__方法，创造一个对象，判断这个属性是否在这个类中，如果不在，则使用object.__new__(cls)方法得到类的属性值。返回这个类的属性值
# 如果已存在，则直接返回已存在的类的属性值
class A: #_instance=None def __init__(self,name): self.name=name def __new__(cls, *args, **kwargs): #if not A._instance: if not hasattr(cls ,‘_instance‘): A._instance=object.__new__(cls) return A._instance a1=A(‘yimi‘) #第一次实例化的时候创造一个实例 #a1.name=‘yimi‘ a2=A(‘titi‘) print(a1,a2) #>>><__main__.A object at 0x00000000021DB390> # >><__main__.A object at 0x00000000021DB390> print(a1.name,a2.name) #>>titi titi
item系列
包含了增删改查三种方法：setitem，delitem，getitem
class A: def __init__(self,name,age): self.name=name self.age=age def __getitem__(self, item): #getitem返回一个类中的某个属性对应的值 return self.__dict__[item] def __setitem__(self, key, value): #setitem既可以增加也可以做删除 self.__dict__[key]=value def __delitem__(self, key): #delitem 删除一个对象的属性 del self.__dict__[key] a=A(‘yimi‘,18) print(a[‘name‘]) #>>yimi print(a[‘age‘]) #>>>18 a[‘sex‘]=‘girl‘ print(a.__dict__) #>>{‘name‘: ‘yimi‘, ‘age‘: 18, ‘sex‘: ‘girl‘} del a[‘sex‘] print(a.__dict__) #》》{‘name‘: ‘yimi‘, ‘age‘: 18}
__call__方法:在对象名后面加（），就是执行类中的__call__方法
# class A: # def __call__(self): # print(‘执行我了‘) # a=A()()
hash方法：不可变数据类型都可以被hash
class A: def __init__(self): self.a = 1 self.b = 2 def __hash__(self): return hash(str(self.a)+str(self.b)) a = A() print(hash(a))
# 有一个类,对应这个类产生了100个对象 # 每个对象有三个属性 : 姓名 年龄 性别 # 请对这一百个对象进行去重,如果姓名和性别相同,即便年龄不同也是相同的对象 # 问最简便的方法? class Person:#定义一个类 def __init__(self,name,age,sex):#初始化属性 self.name = name#对象的name属性 self.age = age#对象的age属性 self.sex = sex#对象的sex属性 def __hash__(self):#定义哈希方法 return hash(‘%s%s‘%(self.name,self.sex))#返回hash‘self.name,self.sex‘的值 def __eq__(self, other):#定义一个eq方法 if self.name == other.name and self.sex == other.sex:#如果对象属性等于 return True p_lst = []#定义个空列表 for i in range(100):#打印0到99 p_lst.append(Person(‘egon‘,i,‘male‘))#p_lst列表添加Person(‘egon‘,i,‘male‘) p_lst.append(Person(‘alex‘,i,‘male‘))#p_lst列表添加Person(‘alex‘,i,‘male‘) p_lst.append(Person(‘yuan‘,i,‘male‘))#p_lst列表添加Person(‘yuan‘,i,‘male‘) print(p_lst) print(set(p_lst)) # 报错不可hash 完成了__hash__ # hash是否相等 __hash__ # 值是否相等 __eq__ # 收获1 # 对于一些python当中已经存在的内置函数 内置数据类型 内置模块中的方法 # 都有可能依赖于类中的内置方法 # 收获2 # set方法依赖集合中元素对象的__hash__ __eq__
from collections import namedtuple#引用一个collections模块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):#定义一个len方法 return len(self._cards)# 返回对象的_cards属性的个数 def __getitem__(self, item):#查询方法 return self._cards[item]#返回一个对象属性的所有内容 def __setitem__(self, key, value): self._cards[key] = value deck = FranchDeck() print(‘**‘,deck[:]) from random import choice#引入选择模块 print(choice(deck)) # deck对象对应的类中的getitem方法和len方法 from random import shuffle#打乱顺序 shuffle(deck)#打印顺序 print(‘**‘,deck[:])
