特殊成员

1.初始化方法 "_init_"

#用于给对象中赋值，初始化方法
'''
顶头是py文件的注释
'''
 class Foo:
     '''
     类的注释
     '''

     def __init__(self,a1):
         '''
         方法的注释
         初始化方法
         :param a1:
         '''
         self.a1 = a1
#1.创建一个空白对象，obj
#2.执行__init__，给对象中进行赋值（初始化）
obj = Foo("yang")

2.__new__方法(构造方法)

#new方法（构造方法）是用来帮助创建空对象的
class Foo(object):
    def __init__(self):
        print("给对象进行赋值")
        self.x = 123

    def __new__(cls,*args,**kwargs):
        print("创建对象")
        return object.__new__(cls) #返回什么，obj就等于什么

obj = Foo()
#当创建对象时先执行__new__再执行__init__方法

3_call_

#对象后面加括号，执行__call__方法
class Foo(object):
    def __init__(self):
        print("给对象进行赋值")
        self.x = 123

    def __new__(cls,*args,**kwargs):
        print("创建对象")
        return object.__new__(cls) #返回什么，obj就等于什么

    def __call__(self,*arg,**kwargs):
        print("执行call方法")
# obj = Foo()
# obj()
Foo()()
#当创建对象时先执行__new__再执行__init__方法

4._getitem_ setitem _delitem_

#语法的对应关系，是只关于字典的吗？这是一个问题？？？其实看样子是只关于字典的
class Foo(object):

    def __setitem__(self, key, value):
        print(key,value)

    def __getitem__(self,item): #此处的item就是“xxx”
        return item + "uuu" #为其返回值

    def __delitem__(self,key):
        pass

obj1 = Foo()
obj1["k1"] = 123 #内部会自动调用__settitem__方法：
val = obj1["xxx"] #内部会自动调用__getitem__方法进行取值
print(val)
del obj1["ttt"] #内部会自动调用__delitem__方法

5_str_

class Foo(object):
    def __str__(self):
        '''
        只有在打印对象时，会自动化调用此方法，并将其返回值在页面显示出来
        :return:
        '''
        return "kasguuas"

obj = Foo()
print(obj) #打印的时候执行__str__返回的内容，对象还是原来的对象,不会影响obj的值，只在打印的时候调用__str__

#__str__应用示例
#改进前
class User(object):
    def __init__(self,name,email):
        self.name = name
        self.email = email

user_list = [User("二狗","2g@qq.com"),User("二蛋","2d@qq.com"),User("狗蛋","gd@qq.com")]
for item in user_list:
    print(item.name,item.email)
 
#改进后
class User(object):
    def __init__(self,name,email):
        self.name = name
        self.email = email

    def __str__(self):
        return "%s %s"%(self.name,self.email)

user_list = [User("二狗","2g@qq.com"),User("二蛋","2d@qq.com"),User("狗蛋","gd@qq.com")]
for item in user_list:
    print(item) #当print对象时便触发__str__e

6_dict_

#去对象中找到所有变量并将其装换为字典
class Foo(object):
    def __init__(self,name,age,email):
        self.name = name
        self.age = age
        self.email = email

obj = Foo("yang",19,"xxxx@qq.com")
print(obj.name)
print(obj.age)
print(obj.email)
val = obj.__dict__ #去对象中找到所有变量并将其装换为字典
print(val)
'''
yang
19
xxxx@qq.com
{'name': 'yang', 'age': 19, 'email': 'xxxx@qq.com'}
'''

上下文管理

class Foo():
    
    def __enter__(self):
        self.x = open("a.text",mode="a",encoding="utf-8")
        return self.x
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.x.close()
        
with Foo() as ff: #ff为enter的返回值
   ff.write("yang")
'''
思考：
这样做的目的是什么？
1.open应该是一个内置的函数，是封装好的函数。这里是把open扒开了进行解析，
由此可以看出open应该包含两个函数，但不是完全的，因为我们在调用函数后还要对函数进行关闭
2.这里面进行了好几次的对象的传递，所以精简了许多中间的传递布置
'''

#面试题
class Context:
    def __enter__(self):
        print("进入")
        return self #此处实际上是对ctx进行传参

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("退出")

    def do_something(self):
        print("内部执行")


with Context() as ctx: #参数之间进行传递，比直接调用显得麻烦，但就是函数内部的逻辑
    ctx.do_something()

两对象相加

class Foo(object):
    def __add__(self, other): 
        return 123  #返回什么val就是什么，pass时返回的为相加的函数
    

obj1 = Foo()
obj2 = Foo()
val = obj1 + obj2 #obj1首先触发__add__，即self为obj1，other为obj2
print(val)

特殊成员

特殊成员

总结：特殊方法就是为了能够快速执行某种方法而生的