特殊成员

特殊成员

• 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)
  

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