面向对象---嵌套/特殊方法

1.嵌套

• 类/方法/对象都可以当做变量或嵌套到其他类型中.
• 函数的参数可以是任意类型.
• 可哈希(不可变)数据类型可以做字典的key.
• 类和对象可以做字典的key.

2.特殊方法(8)

• __init__ #初始化方法: 用于给对象赋值

  class Foo:
      """
      类是干啥的。。。。
      """
      def __init__(self,a1):
          """
          初始化方法
          :param a1: 
          """
          self.a1 = a1
          
  obj = Foo('alex')
  

• __new__ #构造方法: 在init之前用于创建对象

  class Foo(object):
      def __init__(self):
          """
          用于给对象中赋值，初始化方法
          """
          self.x = 123
      def __new__(cls, *args, **kwargs):
          """
          用于创建空对象，构造方法
          :param args: 
          :param kwargs: 
          :return: 
          """
          return object.__new__(cls)
  
  obj = Foo()
  

• __call__ 对象后面加()执行cal方法;

  class Foo(object):
      def __call__(self, *args, **kwargs):
          print('执行call方法')
  
  # obj = Foo()
  # obj()
  Foo()()
  

• __getitem__ __setitem__ __delitem__

  class Foo(object):
  
      def __setitem__(self, key, value):
          pass
  
      def __getitem__(self, item):
          return item + 'uuu'
  
      def __delitem__(self, key):
          pass
  
  
  obj1 = Foo()
  obj1['k1'] = 123  # 内部会自动调用 __setitem__方法
  val = obj1['xxx']  # 内部会自动调用 __getitem__方法
  print(val)
  del obj1['ttt']  # 内部会自动调用 __delitem__ 方法
  

• __str__打印一个对像时,str返回什么打印什么

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

• __dict__

  class Foo(object):
      def __init__(self,name,age,email):
          self.name = name
          self.age = age
          self.email = email
  
  obj = Foo('alex',19,'xxxx@qq.com')
  val = obj.__dict__ # 去对象中找到所有变量并将其转换为字典
  print(val)
  

• 上下文管理

  class Foo(object):
      def do_something(self):
          print('内部执行')
  
  class Context:
      def __enter__(self):
          print('进入')
          return Foo()
  
      def __exit__(self, exc_type, exc_val, exc_tb):
          print('推出')
  
  with Context() as ctx:
      print('内部执行')
      ctx.do_something()
  

• __add__两个对象相加

  val = 5 + 8
  print(val)
  
  val = "alex" + "sb"
  print(val)
  
  class Foo(object):
      def __add__(self, other):
          return 123
      
  obj1 = Foo()
  obj2 = Foo()
  val  = obj1 + obj2
  print(val)
  

  • 特殊成员：就是为了能够快速实现执行某些方法而生。

3.内置函数补充

1. type

• 查看数据类型

  class Foo:
      pass
  
  obj = Foo()
  
  if type(obj) == Foo:
      print('obj是Foo类的对象')
  
  

2. issubclass

• 查看是不是有继承关系

  class Base:
      pass
  
  class Base1(Base):
      pass
  
  class Foo(Base1):
      pass
  
  class Bar:
      pass
  
  print(issubclass(Bar,Base))
  print(issubclass(Foo,Base))
  
  

3. isinstance

• 判断一个对象是不是父类或者基类的实例

  class Base(object):
      pass
  
  class Foo(Base):
      pass
  
  obj = Foo()
  
  print(isinstance(obj,Foo))  # 判断obj是否是Foo类或其基类的实例（对象）
  print(isinstance(obj,Base)) # 判断obj是否是Foo类或其基类的实例（对象）
  
  

4. super().func()

class Base(object): # Base -> object
    def func(self):
        super().func()
        print('base.func')

class Bar(object):
    def func(self):
        print('bar.func')

class Foo(Base,Bar): # Foo -> Base -> Bar
    pass

obj = Foo()
obj.func()

# super().func() 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

4.异常处理

1. 基本格式

   try:
       pass
   except Exception as e:
       pass
   
   

• finally 只要try的内容终止,最后无论对错都会执行

  try:
      int('asdf')
  except Exception as e:
      print(e) # e是Exception类的对象，中有一个错误信息。
  finally:
      print('最后无论对错都会执行')
  
  

  • 主动触发异常

  try:
      int('123')
      raise Exception('阿萨大大是阿斯蒂') # 代码中主动抛出异常
  except Exception as e:
      print(e)
  
  

  def func():
      result = True
      try:
          with open('x.log',mode='r',encoding='utf-8') as f:
              data = f.read()
          if 'alex' not in data:
              raise Exception()
      except Exception as e:
          result = False
      return result
  
  

  • 自定义异常

  class MyException(Exception):
      pass
  
  try:
      raise MyException('asdf')
  except MyException as e:
      print(e)
  
  

  class MyException(Exception):
      def __init__(self,message):
          super().__init__()
          self.message = message
  
  try:
      raise MyException('asdf')
  except MyException as e:
      print(e.message)