24，内置方法的应用，（实现单利模式）

__new__：创建出一个对象

__init__：初始化方法

# __new__  创建一个对象
# class A:
#     def __init__(self):
#         print('init')
#     def __new__(cls, *args, **kwargs):
#         print('new')
#         self = object.__new__(cls)
#         return self
# object __new__创造对象
# a = A()

算法和设计模式
设计模式 —— java开发过程中的一种规范或者设计范式

class A:
    __instance = None
    def __init__(self,name):
        self.name = name
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance
a = A(54)
b = A(56)
print(a is b)
print(id(a))
print(id(b))
print(a.name)
print(b.name)
print(hash(a))
print(hash(b)

__del__：析构方法：

对应着一个对象的删除之前执行的内容

python解释器

#能够主动回收不用的变量

#在程序结束的时候所有的数据都会被清除

#如果用户主动删除某个变量，那么这个变量将会主动的被删除。

无论上述哪种方式：

在删除一个变量之前都会主动执行析构方法__del__

class B:
    def __del__(self):
        print('heheh')
BA = B()
del BA
print(BA)

class B:
    def __init__(self,path):
        self.f = open(path)
    def __del__(self):
        self.f.close() #对象删除之前回归一些操作系统资源。
BA = B('userinfo')

Item系列：打辅助的功能

实现了之后，就是使用[]去做一些事情了。

有一些内置模块中的内置方法是依赖__getitem__调用方法的

或者说是依赖item[‘a’]这种调用方式的。

class Item:
    def __getitem__(self, item):#定义getitem可以使用[]方法。
        print('...',item)
        return self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key] = value
        print(key,value)
    # def __delitem__(self, key):
    #     self.__dict__.pop(key)
item = Item()
# print(item.__dict__)
item['a'] = 'alex' #在创建或者修改的时候，是通过setiem创建的，如果没有该方法，不能创建。
print(item['a'])
print(item.__dict__)
# del item.a
del item['a']
print(item.__dict__)#在执行删除对象属性的时候，是通过__delitem__删除的，如果没有该方法，不能创建。

扑克

from collections import namedtuple
Card = namedtuple('Card',['rank','suit'])  # 属性一旦创建就不再改变了，且可以使用属性名直接访问值
card1 = Card('K','黑桃')
print(card1.rank)
print(card1.suit)

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]

deck = FranchDeck()
# print(deck._cards[0])   #
print(deck[0])
from random import choice
print(choice(deck))   # choice接收iterable,__len__,__getitem__
print(choice(deck._cards))   # choice接收iterable,__len__,__getitem__
print(choice(deck))
print(choice(deck))
print(choice(deck))
print(choice(deck))

进阶版扑克

from collections import namedtuple
Card = namedtuple('Card',['rank','suit'])
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, item,value):
        self._cards[item]  = value

deck = FranchDeck()
from random import shuffle
# shuffle(deck._cards)
# print(deck._cards)
shuffle(deck)     # __len__(self) __getitem__ __setitem__
print(deck._cards)