__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()才是真正的实例化方法
_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(1, 2, 3, 4)
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))
单例模式：
下面设计一个让你类创建的对象都是同一个内存地址
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‘, 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
原文地址：https://www.cnblogs.com/askzyl/p/8886348.html