Python【第五篇】面向对象下

本章概述

• @property装饰器
• 特殊成员和魔法方法

@property装饰器

　　Python内置的@property装饰器可以把类的方法伪装成属性调用的方式，也就是原来使用Foo.func()调用方法，变成Foo.func的方式。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'tian'
__data__ = '2019/4/17 18:24'

class People:
    def __init__(self,name,age):
        self.__name = name
        self.__age   = age

    @property
    def age(self): #获取查看
        return self.__age

    @age.setter
    def age(self,age): #设置重新赋值
        if isinstance(age,int):
            self.__age = age
        else:
            raise  ValueError

    @age.deleter
    def age(self): #删除
        print("删除年龄数据!")

obj = People("tian",18)
print(obj.age) #获取值
obj.age = 19    #重新赋值
print("obj.age是多少啊:",obj.age)
del  obj.age   #删除属性

输出：
>>> 18
>>> obj.age是多少啊: 19
>>> 删除年龄数据

将一个方法伪装成为属性后，就不再使用圆括号的调用方式了。而是类似变量的赋值、获取、和删除方法了。

如何将一个普通的方法转换为一个【伪装】的属性呢？

• 首先在普通方法上添加@property装饰器，例如上面的age()方法。相当于一个get方法，用于获取值，执行代码：resutl = obj.age
• 写一个同名的方法，添加@xxx.setter装饰器（xxx表示和上面方法一样的名字），例如上面的第二个方法。相当于编写了一个set方法，提供赋值功能，执行代码：obj.age = ...
• 再写一个同名的方法，并添加@xxx.delete装饰器，例如上面的第三个方法。用于删除成功，执行代码：del obj.age

总结：将三个方法定义为对同一个属性的获取、修改、和删除。还可以定义只读属性，也就是只定义getter方法，不定义setter方法就是一个只读属性。

 特殊成员和魔法方法

Python中有大量类似__doc__这种以双下划线开头和结尾的特殊成员及【魔法方法】，它们有着非常重要的地位和作用，也是Python语言独具特色的语法之一。

__init__ :  构造函数，在生成对象时调用
__del__  :  析构函数，释放对象时使用
__repr__ :  打印，转换
__setitem__ : 按照索引赋值
__getitem__ : 按照索引获取值
__len__ : 获得长度
__cmp__ : 比较运算
__call__: 调用
__add__ : 加运算
__sub__ : 减运算
__mul__ : 乘运算
__div__ : 除运算
__mod__ : 求余运算
__pow__   :  幂

需要注意这些成员里面有些是方法，调用时要加括号，有些是属性，调用时不需要加括号。

 1、__doc__

　　说明性文档和信息，Python自建，无需自定义。

class Foo:
    """
    描述类信息，可被自动收集
    """
    def func(self):
        pass
    
#对应类的说明文档
print(Foo.__doc__)

2、__init__()

　　实例化方法，通过类创建实例时，自动触发执行。

class Foo:
    def __init__(self,name):
        self.name = name
        self.age  = 18
        
obj = Foo("tian") #自动执行类中的__init__方法

3、__module__ 和 __class__

　　__module__表示当前操作的对象属于哪个模块；

　　__class__ 表示当前操作的对象属于哪个类；

 这两者也是Python内建，无需自定义：

class Foo:
    pass

obj = Foo()
print(obj.__module__) #输出 __main__
print(obj.__class__)   #输出 <class '__main__.Foo'>

4、__del__()

　　析构方法，当对象在内存中被释放时，自动触发此方法。

　　注：此方法一般无须自定义，因为Python自带内存分配和释放机制，除非你需要在释放的时候指定做一些动作。析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:
    def __del__(self):
        print("我被回收了")

obj = Foo()
del obj  

5、__call__()

　　如果为一个类编写了该方法，那么在该类的实例后面加括号，可会调用这个方法。

　　构造方法的执行是由类加括号执行的，即：对象 = 类名() ，而对于__call__()方法，是有对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')

obj = Foo() #执行__init__
obj() #执行__call__
Foo()()

如果判断一个对象是否可以被执行呢？

能被执行的对象就是一个Callable对象，可以用Python内建的callable()函数进行测试：

class Foo:
  def __init__(self):
       pass
    def __call__(self, *args, **kwargs):
        print('__call__')

print(callable(Foo))     #True
print(callable(max))    #True
print(callable([1,2,3])) #False
print(callable(None))  #False
print(callable('str'))  #False
print(callable(int))       #True

6、__dict__

　　列出类或者对象中的所有成员！非常重要和有用的一个属性，Python自建，无需自定义。

class Province:
    country = '广州'
    def __init__(self,name,count):
        self.name  = name
        self.count = count

    def func(self,*args,**kwargs):
        print("这里的func")

#获取类的成员
print(Province.__dict__)

#获取 对象obj1的成员
obj1 = Province("tian",100)
print(obj1.__dict__)

#获取 对象obj2的成员
obj2 = Province("xiang",200)
print(obj2.__dict__)

7、__str__()

　　一个类中定义了__str__()方法，那么在打印对象时，默认输出该方法的返回值，需要自定义。

class Foo:
    pass

obj = Foo()
print(obj) #打印对象的内存地址：<__main__.Foo object at 0x00000000022095F8>

class Fun:
    def __str__(self):
        return "这是一个数据库类"

obj_1 = Fun()
print(obj_1) #打印这是一个数据库类

 8、__iter__()

    迭代器方法，列表、字典、元组之所以可以进行for循环，是因为内部定义了__iter__()这个方法。如果用户想让自定义的类对被迭代，那么就需要在类中定义这个方法，并且让该方法的返回值是一个可迭代的对象。

当在代码中利用for循环遍历对象时，就会调用类的这个__iter__()方法。

class Foo:
    pass
obj = Foo()
for i in obj: #这样会报错:TypeError: 'Foo' object is not iterable
    print(i)

class Foo:
    def __iter__(self):
        pass

obj = Foo()
for i in obj: #这样会报错:TypeError: iter() returned non-iterator of type 'NoneType'
    print(i)  

class Foo:
    def __init__(self,sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj = Foo([11,22,33,44,55])
for i in obj: #输出正常
    print(i)

最好的方法是使用生成器

class Foo:
    def __init__(self):
        pass
    def __iter__(self):
        yield 1
        yield 2
        yield 3
        
obj = Foo()
for i in obj:
    print(i)

9、__len__()

　　python中，如果调用内置的len()函数获取一个对象的长度，在后台其实是去调用该对象的__len__()方法；

>>> len('ABC')

>>> 3

>>>'ABC'.__len__()

>>>3

Python的list、dict、str等内置数据类型都实现了该方法；但是在自定义类要实现len方法下好好设计。