python基础之面向对象-下

在上篇中查看上篇，我们主要介绍了面向对象的基本思想和概念，以及如何给类、实例绑定属性和方法。这篇主要介绍类的装饰器、继承、静态方法、类方法等。

一、类装饰器

python装饰器是程序开发中经常用到的功能，要理解装饰器，首先要明确：
1、函数装饰器在导入模块时立即执行，而被装饰的函数只在明确调用时运行。
2、在python中函数是一种特殊的变量，即函数也可以作为参数传递给其他的函数。
对装饰器不了解的可以在此查看点击这里查看装饰器

# -*- coding:utf-8 -*-
class Hello:
    def info(self, func):
        func()

s = Hello()

@s.info
def f():
    print("hello world!")

输出：

hello world!

如上：装饰器在导入时便立即执行，此时会把f（）当做参数传递到info里的func参数。
复杂的装饰器：

# -*- coding:utf-8 -*-
import time

class Hello:
    def info(self, f):
        print("f:", f)
        def second_func(func):
            def thired_func(*args):
                if f == "1":
                    new_time = time.strftime("%y-%m-%d", time.localtime())
                elif f == "0":
                    new_time = time.strftime("%y-%m-%d", time.localtime())
                print(func.__name__, *args, new_time)

            return thired_func
        return second_func

s = Hello()

@s.info("1")
def f(a, b):
    print("hello world!")

f(1,2)

输出：

f: 1
f 1 2 20-04-30

同样的，@s.info(“1”)中1首先作为info的参数传入info，接下来f会作为参数传入second_func，最终（1，2）会作为参数传入third_func，一层一层，抽丝剥茧。

二、property装饰器

property装饰器可以把类的方法伪装成类的属性调用的方式。这在好多时候非常有用，能够帮助你写出简洁、优美的代码。

# -*- coding:utf-8 -*-
class Stu(object):
    __name = "male"
    __age = 0

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self,v):
        if not isinstance(v,int):
            raise ValueError("值错误")
        if v > 130 or v < 0:
            raise ValueError("值错误")
        self.__age = v

    @age.deleter
    def age(self):
        print("删除用户数据")

m = Stu()
m.age = 100
print(m.age)
del m.age

输出：

100
删除用户数据

在普通方法的基础上添加@property装饰器，例如上面的age()方法。这相当于一个get方法，用于获取值,决定类似"result = obj.age"执行什么代码。该方法仅有一个self参数。写一个同名的方法，添加@xxx.setter装饰器（xxx表示和上面方法一样的名字），比如例子中的第二个方法。这相当于编写了一个set方法，提供赋值功能，决定类似"obj.age = …"的语句执行什么代码。再写一个同名的方法，并添加@xxx.delete装饰器，比如例子中的第三个方法。用于删除功能，决定"del obj.age "这样的语句具体执行什么代码。

三、继承

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。
如果定义了一个class,继承了某个现有的class,新的class称为子类(subclass),而被继承的类称为基类、父类或者超类(Base class,Super class)
继承的好处：代码复用
继承又分为单继承和多继承

3.1 单继承

单继承指只继承一个父类，如：

# -*- coding:utf-8 -*-
# 类定义
class People:
    # 定义基本属性
    name = ""
    age = 0
    __weight = 0
    # 构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说:我目前年龄 %d 正在学PY" %(self.name, self.age))

# 单继承
class Stu(People):
    grade = ""
    def __init__(self, n, a, w, g):
        People.__init__(self, n, a, w)
        self.grade = g
    # 重写父类的方法
    def speak(self):
        print("%s说:我目前年龄%d正当学PY,我目前是%s年级" % (self.name, self.age, self.grade))

p1 = Stu("lyy", 15, 120, "2")
p1.speak()
p2 = People("md", 45, 75)
p2.speak()

输出：

lyy说:我目前年龄15正当学PY,我目前是2年级
md 说:我目前年龄 45 正在学PY

子类Syu继承了父类People的方法。

3.2 多继承

多继承是指继承了多个父类，在多继承时，不免要提到的一个问题就是继承的顺序，在搞清楚继承顺序前，我们需要明白两个概念：深度优先和广度优先。

在py2.x版本中经典类是按照深度优先的顺序来进行的，新式类是按照广度优先的顺序来进行的；
在py3.x版本中，再无经典类和新式类之分，统一按照广度优先来进行。

class BaseClass(object):
    def show(self):
        print('BaseClass')

class SubClassA(BaseClass):
    def show(self):
        print('Enter SubClassA')
        super().show()
        print('Exit SubClassA')

class SubClassB(BaseClass):
    def show(self):
        print('Enter SubClassB')
        super().show()
        print('Exit SubClassB')

class SubClassC(SubClassA):
    def show(self):
        print('Enter SubClassC')
        super().show()
        print('Exit SubClassC')

class SubClassD(SubClassB, SubClassC):
    def show(self):
        print('Enter SubClassD')
        super().show()
        print('Exit SubClassD')

d = SubClassD()
d.show()

继承关系如下图：

输出：

Enter SubClassD
Enter SubClassB
Enter SubClassC
Enter SubClassA
BaseClass
Exit SubClassA
Exit SubClassC
Exit SubClassB
Exit SubClassD
[<class '__main__.SubClassD'>, <class '__main__.SubClassB'>, <class '__main__.SubClassC'>, <class '__main__.SubClassA'>, <class '__main__.BaseClass'>, <class 'object'>]

顺序为D-B-C-A-BaseClass
当把SubClassD继承的顺序调换后，如：class SubClassD(SubClassC, SubClassB):访问的顺序变为D-C-A-B-BaseClass
输出：

Enter SubClassD
Enter SubClassC
 Enter SubClassA
Enter SubClassB
BaseClass
Exit SubClassB
Exit SubClassA
Exit SubClassC
Exit SubClassD
[<class '__main__.SubClassD'>, <class '__main__.SubClassC'>, <class '__main__.SubClassA'>, <class '__main__.SubClassB'>, <class '__main__.BaseClass'>, <class 'object'>]

四、静态方法

静态方法：用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。
注意
1、静态方法无法调用实例变量。
2、调用时并不需要传递类或者实例。像我们在类外定义的函数，只不过静态方法可以通过类或者实例来调用而已。

class Eat:
    name = "jsonwong"
    age = 18
    @staticmethod
    def func():
        print('hello world!')
eat = Eat()
eat.func()

输出：

hello world!

五、类方法

类方法通过@classmethod装饰器实现。
注意
1、类方法只能访问类变量，不能访问实例变量。
2、通过cls参数传递当前类对象，不需要实例化，直接通过类对象【实例名.方法名】和类对象实例【类名.方法名】访问。

class Eat:
    name = "jsonwong"
    food = "牛肉"
    def __init__(self, food):
        self.food = food
    @classmethod
    def func(cls):
        print('hello world!', cls.food)
eat = Eat("羊肉")
eat.func()

输出：

hello world! 牛肉

注意，上面可以看到类方法只能访问类变量，而不能访问实例变量。

六、类的专有方法

专有方法名称	解释
_init_	构造方法，生成对象时使用
_del_	解析函数，释放对象时使用
_dict_	字典，记录类属性信息
_len_	获得长度
_mro_	方法查询
_str_	给用户展示
_repr_	给解析器看