面向对象进阶------>内置函数 str repr new call 方法

__new__方法：

我们来讲个非常非常重要的内置函数和init一样重要__new__其实在实例话对象的开始  是先继承父类中的new方法再执行init的  就好比你生孩子 先要把孩子生出来才能对孩子穿衣服的  new就是生孩子 init是给孩子穿衣服

new()是在新式类中新出现的方法，它作用在构造方法init()建造实例之前，可以这么理解，在Python 中存在于类里面的构造方法init()负责将类的实例化，而在init()调用之前，new()决定是否要使用该init()方法，因为new()可以调用其他类的构造方法或者直接返回别的对象来作为本类 的实例。 
如果将类比喻为工厂，那么init()方法则是该工厂的生产工人，init()方法接受的初始化参 数则是生产所需原料，init()方法会按照方法中的语句负责将原料加工成实例以供工厂出货。而 new()则是生产部经理，new()方法可以决定是否将原料提供给该生产部工人，同时它还决定着出 货产品是否为该生产部的产品，因为这名经理可以借该工厂的名义向客户出售完全不是该工厂的产品。 
new()方法的特性： 
new()方法是在类准备将自身实例化时调用。 
new()方法始终都是类的静态方法，即使没有被加上静态方法装饰器。

而在实例化开始之后，在调用 init()方法之前，Python首先调用new()方法：

如果以建房子做比喻，new()方法负责开发地皮，打下地基，并将原料存放在工地。而init()方法负责从工地取材料建造出地皮开发招标书中规定的大楼，init()负责大楼的细节设计，建造，装修使其可交付给客户。

在新式类中new()才是真正的实例化方法

内置方法 必须能看懂 能用尽量用
__len__ len(obj)的结果依赖于obj.__len__()的结果，计算对象的长度
__hash__ hash(obj)的结果依赖于obj.__hash__()的结果，计算对象的hash值
__eq__ obj1 == obj2 的结果依赖于obj.__eq__()的结果,用来判断值相等
__str__ str(obj) print(obj) '%s'%obj 的结果依赖于__str__,用来做输出、显示
__repr__ repr(obj) '%r'%obj的结果依赖于__repr__,还可以做str的备胎
__format__ format() 的结果依赖于__format__的结果，是对象格式化的
__call__ obj()相当于调用__call__，实现了__call__的对象是callable的
__new__ 构造方法，在执行__init__之前执行，负责创建一个对象，在单例模式中有具体的应用
__del__ 析构方法，在对象删除的时候，删除这个对象之前执行，主要用来关闭在对象中打开的系统的资源

_str__和__repr__方法：

来讲一下类中经常用到的 内置函数  __str__和__repr__方法

我个人理解  __repr__是比__str__方法功能更加强大的 一个方法  能让你使用的更加广泛   str就是你在打印你实例的对象的时候你所对类中str方法返回的内容会被输出

__str__和__repr__方法一样它不能用print直接输出 必须用return来返回  然后返回的也必须是字符串类型的

class  List:
    def __init__(self, *args):
        self.l = list(args)
    # def __str__(self):
    #     return'[%s]' %(','.join([str(i) for i in self.l]))  #把你传递进来的 迭代对象中的信息中的元素都转化为字符串类型的  然后把 信息再给转化为列表的额形式输出
    def __str__(self):  #__str__类型的必须是要用return来返回的  并且返回值也必须是字符串类型的
        return 'niha'
l = List(, , , )
print(l)

当需要使用__str__的场景时找不到 __str__就找__repr__当需要使用__repr__的场景时找不到__repr__的时候就找父类的repr双下repr是双下str的备胎

当你的语句中同时出现 str  和repr的时候一定会执行repr里面的内容 因为有repr的同时不会执行str内的内容

__len__方法

len方法估计也和str一样但是返回的只能是int类型 它和len是有着莫大关联的

class A:

    def __len__(obj):
       return 222

a = A()
print(len(a))

单例模式：

python中的单例模式 是依靠__new__方法来实现的

下面设计一个让你类创建的对象都是同一个内存地址

就是你创建的所有的对象都是在同一个内存空间，后创建的对象会把之前的空间给覆盖掉

因为你创建对象是开辟一个空间的，并且创建对象是__new__方法来控制的，那么设置不让他调用父类的new方法进行创建对象就可以控制了单例

class B:
    __instance =  None
    def __new__(cls,*args, **kwargs):
        if cls.__instance is None :  #  类调用自己的私有属性
            obj = object.__new__(cls) # 基类在这里就是父类调用自己new就是创建了一个对象 开辟了一个空间
            cls.__instance = obj  # 把开辟空间赋值给了  自己的私有属性 进行值的改变
        return cls.__instance # 私有属性不是了就不会再执行者里面的过程了

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)

a = B('alex', 70)
b = B('agon', 40)
# print(a)
# print(b)
print(a.name)
print(b.name)

# item  对象使用中括号的形式去操作

# __call__
# class Teacher():
#     def __call__(self):
#         print(123)
#     def call(self):print(123)
# t = Teacher()
# t.call()
# t()   # 对象名() 相当于调用类内置的__call__
# 一个对象是否可调用 完全取决于这个对象对应的类是否实现了__call__
# callable
# print(callable(Teacher))
# print(callable(t))

# class A:
#     def __eq__(self, other):
#         # if self.__dict__ == other.__dict__:
#             return True
# # __eq__()
# a = A()
# a.name = 'alex'
# b = A()
# b.name = 'egon'
# print(a)
# print(b)
# print(a == b)

# == 是由__eq__的返回值来决定的

# __del__ 析构方法:  在删除一个对象的时候做一些首尾工作
# class A:
#     def __init__(self):
#         pass
#         # self.f = open('文件','w')
#     def __del__(self):
#         print('执行我啦')
# a = A()
# del a
# print('aaa')

# class A:
#     def __init__(self):
#         self.f = open('文件','w')
#     def __del__(self):
#         self.f.close()
#         print('执行我啦')
# a = A()
# del a
# print(a)
# print('aaa')

# __new__ 构造方法
# 实例化的时候
# 创造对象的过程  __new__
# __init__ 初始化

# 设计模式 —— 单例模式
# 单例模式 就是 一个类 只能有一个实例
# class A:pass
# a = A()
# b = A()
# print(a)
# print(b)

# class B:
#     __instance = None
#     def __new__(cls, *args, **kwargs):
#         if cls.__instance is None:
#             obj = object.__new__(cls)
#             cls.__instance = obj
#         return cls.__instance
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def func(self):
#         print(self.name)
# a = B('alex',80)
# b = B('egon',20)
# print(a)
# print(b)
# print(a.name)
# print(b.name)

# item
# dic = {'k':'v'}
# print(dic['k'])

# class Foo:
#     def __init__(self,name):
#         self.name=name
#
#     def __getitem__(self,item):
#         return  self.__dict__[item]
#
#     def __setitem__(self, key, value):
#         self.__dict__[key]=value
#
#     def __delitem__(self, key):
#         print('del obj[key]时,我执行')
#         self.__dict__.pop(key)

# f = Foo('alex')
# # f.name = ...
# print(f['name'])    # f.__getitem__('name')
# f['age']  = 18      # 赋值
# print(f.age)         # 自带的语法
# print(f['age'])     # 修改
# f['age']  = 80
# print(f['age'])     # 通过实现__getitem__得到的
# del f['age']
# print(f.age)         # 删除

# class Foo:
#     def __init__(self,name):
#         self.name=name
#     def __delattr__(self, item):
#         print('del obj.key时,我执行')
#         self.__dict__.pop(item)
# f = Foo('alex')
# del f.name     #相当于执行了__delattr__
# # delattr(f,'name')

# 100个同一个类的对象
# Person name age sex
# 100 name sex
# class A:
#     pass

__call__方法：

类直接加括号obj（）就相当于调用了call方法 你要执行这个方法需要再后面再加上括号  才能执行

class  B:
    def __call__(self):
        return 6666

b = B()
B() #这一步你是调用call方法
print(b())  #这一步是实现这个方法

class  B:
    def __call__(self):
        print(4444)

b = B()
B()() 

只有一个对象   只开了一个内存空间
创建一个类 单例模式中的对象属性编程类中的静态属性，所有的方法变成类方法
设计模式 —— java
python中的单例模式 是使用__new__