一、类的内置方法（魔术方法）
类的内置方法：
凡是在类内部定义，以__ 开头 __ 结尾 (如__ init __) 的方法都是类的内置 方法，也称为魔术方法
类的内置方法，会在某种条件满足下自动触发。
内置方法如下：
__ new __ __:在 __ __ init __触发前，自动触发，调用该类时，内部会通过
__ new__ 产生一个新的对象。
__ init __ :在调用类时自动触发。通过产生的对象调用 __ init __ ()
# 1
class Demo(object):
#条件：__new__: 在__init__前自动触发
def __new__(cls, *args, **kwargs):
print('此处是__new__方法的执行')
#python内部通过object调用内部的__new__实现产生一个空的对象---->内存地址
return object.__new__(cls, *args, **kwargs)
def __init__(self):
print('此处是__init__方法的执行')
demo_obj = Demo()
print(demo_obj) #<__main__.Demo object at 0x103d887f0>
'''
结果：
此处是__new__方法的执行
此处是__init__方法的执行
<__main__.Demo object at 0x103d887f0>
'''
# 2
class Demo1(object):
#__getattr__:在'对象.属性'获取属性时，若'属性没有'时触发
def __getattr__(self, item):
print('此处是__getattr__方法的执行')
print(item)
#return 想要返回的值
return 'tank is very very handsome'
demo1_obj = Demo1()
print(demo1_obj.x, '想要返回的值')
'''
结果：
此处是__getattr__方法的执行
x
tank is very very handsome 想要返回的值
'''
demo1_obj.x = 10
print(demo1_obj.x, '属性有时不会触发__getattr__...')
'''
结果：
10 属性有时不会触发__getattr__...
'''
#3
#条件：__getattribute__ :在'对象.属性'获取属性时，无论'属性有没有'都会触发。
class Demo2(object):
def __getattribute__(self, item):
print(item, '<----打印属性名字')
return self
# return self.__dict__[item] #递归，死循坏
#注意此处不能通过 对象.属性，否则会产生递归调用，程序崩溃
#getattr:内部调用了----->__getattribute__
#return getattr(self, item)
#注意：只要__getattr__ 与__getattribute__ 同时存在类的内部，只会触发__getattribute__
demo_obj2 = Demo2()
print(demo_obj2.x)
'''
结果：
x <----打印属性名字
<__main__.Demo2 object at 0x1088516d0>
'''
#4
# 条件：当'对象.属性 = 属性值'，添加或修改属性时触发
class Demo3(object):
def __init__(self):
pass
def __setattr__(self, key, value): #key---->对象.属性名 value----> 属性值
print('此处是__setattr__方法的执行')
print(key, value)
#出现递归
#self.key = value
#print(self.__dict__)
#此处是对对象的名称空间---》字典进行操作
self.__dict__[key] = value
#原来设置属性时，会自动触发父类中的__setattr__, 内部为对象添加x属性，值为20
demo_obj3 = Demo3()
print(demo_obj3.__dict__)#{}
demo_obj3.x = 10
print(demo_obj3) #此处是__setattr__方法的执行
#x 10
#<__main__.Demo3 object at 0x10fe006d0>
print(demo_obj3.__dict__) #{'x': 10}
# 5
# 条件：在打印对象时触发
# 注意：该方法必须要有一个'字符串'返回值
class Demo4(object):
def __str__(self):
print('此处是__str__方法的执行')
return '111' #如果没有返回值时会报错
demo_obj4 = Demo4()
print(demo_obj4) #111,
# 6
# #条件：在调用对象 '对象+（）'时触发
class Demo5(object):
def __call__(self, *args, **kwargs):
print('此处是__call__方法的执行')
#调用对象时返回的值
return [1,2,3,4,5]
demo_obj5 = Demo5()
print(demo_obj5()) #此处是__call__方法的执行
#[1, 2, 3, 4, 5]
# 7
# 在对象通过'对象[key]'获取属性时触发
class Demo6(object):
def __getitem__(self, item):
print('此处是__getitem__方法的执行')
print(item)
return self.__dict__[item]
demo6_obj = Demo6()
demo6_obj.x = 10
print(demo6_obj['x'])
'''
结果：
此处是__getitem__方法的执行
x
10
'''
#8
#在对象通过'对象[key] = value'设置属性时触发
class Demo7(object):
def __setitem__(self, key, value):
print('此处是__setitem__方法的执行')
print(key, value)
print(self.__dict__)
self.key = value
print(self.__dict__)
self.__dict__[key] = value
demo7_obj = Demo7()
demo7_obj['x']= 10
'''
结果：
此处是__setitem__方法的执行
x 10
{}
{'key': 10}
'''
单例模式：
-单例模式是一种设计模式
-指的是在确定‘’类中的属性与方法‘’不变时，需要反复用该类，让所有的对象都执行同一个内存地址
优点：节省内存空间
class Foo:
def __init__(self, x, y):
self.x = x
self.y = y
foo_obj1 = Foo(10, 20)
print(foo_obj1.__dict__) #{'x': 10, 'y': 20}
print(foo_obj1) #<__main__.Foo object at 0x10dfe86d0>
foo_obj2 = Foo(10, 20)
print(foo_obj2.__dict__) ##{'x': 10, 'y': 20}
print(foo_obj2) #<__main__.Foo object at 0x10065e910>
单例模式方法：
1.通过classmethod
2.通过装饰器实现
3.通过__ new __ 实现
4.通过导入模块实现
5.通过元类实现
import setting
#通过classmethod
class MySQL:
#一个默认是，用来判断对象是否存在，对象不存在证明值是None
#__instance 是类的属性，可以由类来调用
__instance = None #--->执行到代码
#__instacne = obj
def __init__(self, host, port):
self.host = host
self.port = port
@classmethod
def singlethon(cls,host,port): #单例方法 ----》类方法
print('cls:',cls)
#判断__instance中没有值，证明没有对象
if not cls.__instance:
#产生一个对象并返回
obj = cls(host, port)
print('obj:',obj)
#此时的None转变为obj
cls.__instance = obj
return obj
#若__instance 中有值，证明对象已经存在。证明对象已经存在，则直接返回对象
else:
return cls.__instance
def start_mysql(self):
print('启动mysql')
def close(self):
print('关闭mysql')
obj1 = MySQL.singlethon(setting.host, setting.port)
print(obj1)
obj1.start_mysql()
obj2 = MySQL.singlethon(setting.host, setting.port)
print(obj2)
print(obj2.__dict__)
obj3 = MySQL.singlethon(setting.host, setting.port)
print(obj3) #<__main__.MySQL object at 0x11034acd0>
print(obj3.__dict__) #{'host': '192.168.0.0', 'port': 7070}