Python面向对象中的特殊成员-CFANZ编程社区

一.总述

在python的类中存在一些特殊的方法，格式如__XX__。

这样的方法是python中的特殊成员，他们在python内部具有特殊的含义以及功能，以下将介绍几种常见的特殊成员。

以下将介绍常见的十二种特殊成员

二.常见成员

__new__ 构造方法

在初始化__init__方法之前触发，__new__方法会帮助创建对象

__new__会首先调用object.__new__(cls)创建空对象并返回

class Foo(object):
  def __init__(self,name):
    print('step2:初始化对象，在对象中封装数据')
    self.name = name
    
  def __new__(cls,*arg,**kargs):
    print('step1:创建空对象并返回')
    return object.__new__(cls)
  
  
obj = Foo('uic_47')

实例化的动作触发后，会先执行step1，之后再执行step2初始化对象

在父类（object）中有__new__方法

__call__ 在Python中可以实现对象加括号，来执行类中的__call__方法

class Foo(object):
  def __call__(self,*arg,**kargs):
    print('执行call方法')


obj = Foo()
obj()     # obj加括号可以执行__call__方法

__str__ 该方法必须返回一个字符串

如果想将一个对象转换成str，则调用该方法时会执行类中的__str__方法

返回类中__str__所指定的返回值
```
class Foo(object):
  def __str__(self):
    return 'uic_47'
  
  
obj = Foo()
data = str(obj)
print(data)


>>>uic_47
```

可以在编程中做一些数据的展示

以下是可以用作数据展示的例子：

class Student(object):
  def __init__(self, name, age):
    self.name = name
    self.age = age
    
  def __str__(self):
    return self.name
  
  
student_1 = Student('uic_47',20)
student_2 = Student('uic_477',22)
print(student_1)
print(student_2)


# 不加__str__方法，print后得到的是该对象的内存地址，输出得到
<__main__.Student object at 0x104e93f40>
<__main__.Student object at 0x104e93ee0>

__dict__ 自动获取对象内部的所有实例变量

以字典的形式展示

class Foo(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


obj = Foo("uic_47",19)
print(obj.__dict__)


>>>{'name':'uic_47','age':19}

__getitem__、__setitem__、__delitem__

在Python常见的数据类型字典中，我们支持这样的操作

info = {}


info['name'] = 'uic_47'
info['age'] = 20

del info['name']

__getitem__、__setitem__、__delitem__

以上三个特殊方法可以将自己写的类对应以上的三种语法（操作）

class Foo(object):

    def __getitem__(self, item):
        pass

    def __setitem__(self, key, value):
        pass

    def __delitem__(self, key):
        pass


obj = Foo('uic_47', 19)

obj['x1']
obj['x2'] = 123
del obj['x3']

__enter__、__exit__

# 引子
# 在文件操作中我们使用以下代码

f = open('xxx.log')
f.read()
f.close()
...

# 为了防止忘记关闭文件，我们可以使用上下文管理的方法来实现文件的读取

with open('xxx.log',mode = 'r') as f:
  f.read()

我们可以通过__enter__、__exit__来使我们写的类，以及基于该类实例化的对象也支持这样的语法

class Foo(object):
  def __init__(self):
    pass
  
  def __enter__(self):
    return 'uic_47'
  
  def __exit__(self, exc_type, exc_val, exc_tb):
    pass
  
  
  
obj = Foo()
with obj as f:
  pass

在Python中使用with + 一个对象这样的语法时，在内部会先执行__enter__方法，该方法有返回值，返回值就是with obj as f中的f 。

当with缩进中的代码执行完后，将会自动执行___exit_方法

以下是运行例子：

class Foo(object):
    def __init__(self):
        pass

    def __enter__(self):
        print('before')
        return 'uic_47'

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('after')


obj = Foo()
with obj as f:
    print('hello')
    print(f)
    
    
>>>before
>>>hello
>>>uic_47
>>>after

这样的方法的应用案例

class SqlHelper(object):
  
  def __enter__(self):
    self.连接 = 连接数据库
    return 连接
  
  def __exit__(self, exc_type, exc_val, exc_tb):
    self.连接.关闭
    

with SqlHelper as 连接：
  pass


# 以上内容为简略伪代码

这样的操作可以让我们专注于内容本身，这样的操作可以简化连接与断开连接的操作。

__add__

# 引子
v1 = int(1)
v2 = int(5)

v3 = v1 + v2
print(v3)

>>>6


class Foo(object):
  pass

v1 = Foo()
v2 = Foo()
v3 = v1 + v2
>>> TypeError: unsupported operand type(s) for +: 'Foo' and 'Foo'

只需在类中定义__add__方法，就可以支持对象之间的相加操作，所得到的结果是__add__方法的返回值

class Foo(object):
  def __add__(self, other):
      return 123

v1 = Foo()
v2 = Foo()
v3 = v1 + v2
print(v3)

>>>123

加号右边的第二个对象会被当作__add__ 方法的第二个参数 other传入

class Foo(object):
  def __init__(self,name):
    self.name = name
    
  def __add__(self,other):
    return '{}-{}'.format(self.name,other.name)
  
  
v1 = Foo('uic_47')
v2 = Foo('is hungry')
v3 = v1 + v2
print(v3)


>>>uic-is hungry