Python之面向对象的进阶 （3-13）

Posted 2020-10-27 yimiflh

构造方法：在面向对象中，创建一个对象的过程（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接收

new一个对象

 元类  创造  类 ：所以所有的类的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}

getitem,setitem,delitem

 

__call__方法:在对象名后面加（），就是执行类中的__call__方法

# class A:
#     def __call__(self):
#         print(‘执行我了‘)
# a=A()()

——call——

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))

__hash__方法

 

# 有一个类,对应这个类产生了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[:])

扑克牌游戏