python面向对象：封装，继承，多态

1.面向对象

面向对象是把构成问题的事物分解成各个对象，每个对象都有自己独立的属性和行为, 对象可以将整个问题事务进行分工, 不同的对象做不同的事情, 这种面向对象的编程思想由于更加贴近实际生活, 所以被计算机语言广泛应用。

常见的面向对象编程语言：Java / C++ / Python等等；

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向过程：C

总之，Python中万事万物皆对象，而面向对象的三大特性：封装、继承和多态。

2.类的定义

Python 中定义一个类使用 class 关键字实现，其基本语法格式如下：

class 类名：
    多个（≥0）类属性...
    多个（≥0）类方法...

注意，无论是类属性还是类方法，对于类来说，它们都不是必需的，可以有也可以没有。另外，Python 类中属性和方法所在的位置是任意的，即它们之间并没有固定的前后次序。

和变量名一样，类名本质上就是一个标识符，因此我们在给类起名字时，必须让其符合 Python 的语法。有读者可能会问，用 a、b、c 作为类的类名可以吗？从 Python 语法上讲，是完全没有问题的，但作为一名合格的程序员，我们必须还要考虑程序的可读性。

因此，在给类起名字时，最好使用能代表该类功能的单词，例如用Student作为学生类的类名；甚至如果必要，可以使用多个单词组合而成。

class Dog:
    name: str = "小黑"
    age: int = 2

注意，如果由单词构成类名，建议每个单词的首字母大写，其它字母小写；同属一个类的所有类属性和类方法，要保持统一的缩进格式，通常统一缩进 4 个空格

2.1.实例化对象

对已定义好的类进行实例化，其语法格式如下：

类名(参数)

定义类时，如果没有手动添加 __init__() 构造方法，又或者添加的 __init__() 中仅有一个 self 参数，则创建类对象时的参数可以省略不写。

# 1.实例化对象
# java方式：Dog d1=new Dog();
d1 = Dog()
d2 = Dog()
print(d1)
print(d2)

2.2.类变量

类变量指的是在类中，但在各个类方法外定义的变量。举个例子：

class Dog:
    name: str="小花"
    type: str="金毛"
    age: int = 3

上述代码中，name和age都是类变量。

类变量的特点是，所有类的实例化对象都同时共享类变量，也就是说，类变量在所有实例化对象中是作为公用资源存在的。类方法的调用方式有 2 种，既可以使用类名直接调用，也可以使用类的实例化对象调用。

• 通过类名调用类变量和修改类变量的值：

# 使用类名直接调用
print(f"name={Dog.name},type={Dog.type},age={Dog.age}")
# 修改类变量的值
Dog.name="钱多多"
print(Dog.name)

• 通过类对象来调用所属类中的类变量：(此方式不推荐使用)

# 实例化对象
d1 = Dog()
# 获取对象中的属性
print(f"name={d1.name},age={d1.age}")
# 修改对象中的属性
d1.name="小黑"
d1.gender="公"
print(f"name={d1.name},gender={d1.gender}")

注意：通过类对象是无法修改类变量的。通过类对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该对象定义新的实例变量

• 所有类的实例化对象都同时共享类变量：

class Dog:
    name: str = "小黑"
    age: int = 3
​
d2 = Dog()
d3 = Dog()
print(d2.name)
print(d3.name)
Dog.name="小白"
print(d2.name)
print(d3.name)

显然，通过类名修改类变量，会作用到所有的实例化对象

2.3.函数和实例变量

实例变量指的是在任意类方法内部，以“self.变量名”的方式定义的变量，其特点是只作用于调用方法的对象。另外，实例变量只能通过对象名访问，无法通过类名访问。

给类添加方法，方法就是定义在类中的函数：

class Dog:
    name: str="小花"
    type: str="金毛"
    age: int = 3
    
    def say(self):
        pass

每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。相当于Java中的this

def say(self):
    print(f"你好，我是{self.name}")

携带多个参数时，其他的参数放在 self 之后：

def say(self,food: str):
    print(f"你好，我是{self.name}！我喜欢吃{food}")

类中，实例变量和类变量可以同名，但这种情况下使用类对象将无法调用类变量，它会首选实例变量，这也是不推荐类变量使用对象名调用的原因。

2.3.init()构造函数

在创建类时，我们可以手动添加一个 __init__() 方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）。

构造方法用于创建对象时使用，每当创建一个类的实例对象时，Python解释器都会自动调用它。Python类中，手动添加构造方法的语法格式如下：

def __init__(self,...):
    代码块

注意，此方法的方法名中，开头和结尾各有 2 个下划线，且中间不能有空格。Python 中很多这种以双下划线开头、双下划线结尾的方法，都具有特殊的意义

• 定义类时，如果没有手动添加 __init__() 构造方法，又或者添加的 __init__() 中仅有一个 self 参数，则创建类对象时的参数可以省略不写，如下所示：

class Dog:
    
    def __init__(self):
        print("实例化")
        
d = Dog()

• init() 方法可以包含多个参数，但必须包含一个名为 self 的参数，且必须作为第一个参数。也就是说，类的构造方法最少也要有一个 self 参数。如下所示：

class Dog:
    
    def __init__(self,sname: str,sage: int):
        print("正在使用多参数的init函数进行实例化")
        
d = Dog("小白",2)

• 在python没有重载一说，如果硬是要做，可以使用默认值方式：

class Dog:
    
    def __init__(self,sname: str='',sage: int=0):
        print("正在使用多参数的init函数进行实例化")
​
d = Dog(sname="小白")

2.4.魔法函数

Python 类中，凡是以双下划线 "" 开头和结尾命名的成员（属性和方法），都被称为类的特殊成员（特殊属性和特殊方法）。例如，类的 init__(self) 构造方法就是典型的特殊方法。

• 示例一：__str__()

重载父类object中的__str__()用于将值转化为字符串形式：

class Dog:
    def __str__(self):  
        return f"name={self.name},age={self.age},sex={self.sex}"

• 示例二：__call__()

Python类中一个非常特殊的实例方法，即 __call__()。该方法的功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。

class Dog:
    # 定义__call__方法
    def __call__(self,name,age):
        print("调用__call__()方法",name,age)
d1 = Dog()
d1("小花",2)

可以看到，通过在 Dog 类中实现 __call__() 方法，使的 d1实例对象变为了可调用对象。

函数缓存示例：

class FunCahce:
    """
    函数缓存，可以将函数的执行结果进行缓存，以便于在下次调用时直接从缓存中获取结果。
    如果函数需要缓存可以使用该类包装
    """
    def __init__(self, func):
        self.func = func
        self.cache = {}
​
    def __call__(self, *args):
        if args not in self.cache:
            self.cache[args] = self.func(*args)
            print("use cache")
        return self.cache[args]
​
​
def fibonacci(n):
    """
    定义一个计算斐波那契额数列的函数
    :param n:
    :return:
    """
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
​
​
# 使用函数缓存类包装，通过缓存提升性能，可以将该行注释对比使用缓存与不使用缓存的区别
fibonacci = FunCahce(fibonacci)
​
print(fibonacci(100))
​

更多内容，请查看Python中的魔法函数。

3.三大特性

3.1.封装

简单的理解封装（Encapsulation），即在设计类时，刻意地将一些属性和方法隐藏在类的内部，这样在使用此类时，将无法直接以“类对象.属性名”（或者“类对象.方法名(参数)”）的形式调用这些属性（或方法），而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。

3.3.1.property()函数

我们一直在用“类对象.属性”的方式访问类中定义的属性，其实这种做法是欠妥的，因为它破坏了类的封装原则。正常情况下，类包含的属性应该是隐藏的，只允许通过类提供的方法来间接实现对类属性的访问和操作。

因此，在不破坏类封装原则的基础上，为了能够有效操作类中的属性，类中应包含读（或写）类属性的多个 getter（或 setter）方法，这样就可以通过“类对象.方法(参数)”的方式操作属性，例如：

通过添加 __ 修饰符将变量声明为私有化属性。

class Dog:
    name: str = '小黑'
    age: int = 3
    __sex: str = '公'

被修饰的变量无法再类的外部被访问，但是可以通过 self 对象来调用。

# 提供getter/setter
def get_sex(self):
    return self.__sex
​
def set_sex(self, sex: str):
    self.__sex = sex

3.3.2.类方法

Python 类方法和实例方法相似，它最少也要包含一个参数，只不过类方法中通常将其命名为 cls，Python 会自动将类本身绑定给 cls 参数（注意，绑定的不是类对象）。也就是说，我们在调用类方法时，无需显式为 cls 参数传参。

和 self 一样，cls 参数的命名也不是规定的（可以随意命名），只是 Python 程序员约定俗称的习惯而已。

和实例方法最大的不同在于，类方法需要使用＠classmethod修饰符进行修饰，例如：

class Dog:
    # 类方法
    @classmethod
    def info(cls):
        print(cls)

注意，如果没有 ＠classmethod，则 Python 解释器会将 fly() 方法认定为实例方法，而不是类方法。

类方法推荐使用类名直接调用，当然也可以使用实例对象来调用（不推荐）。

d1 = Dog()
d1.info()
Dog.info()

3.3.3.静态方法

静态方法，其实就是我们学过的函数，和函数唯一的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局命名空间）中。

静态方法没有类似 self、cls 这样的特殊参数，因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。也正因为如此，类的静态方法中无法调用任何类属性和类方法。

静态方法需要使用＠staticmethod修饰，例如：

class Dog:
    # 静态方法
    @staticmethod
    def say():
        print("静态方法被调用了...")

静态方法的调用，既可以使用类名，也可以使用类对象，例如：

d1 = Dog()
d1.say()
Dog.say()

3.2.继承

Python 中，实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。

子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。语法格式如下：

class 类名(父类1, 父类2, ...)：
    #类定义部分

注意，如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）。另外，Python 的继承是多继承机制（和 C++一样），即一个子类可以同时拥有多个直接父类。

class Father(object):
    height=180
    money=100
    def work(self):
        print("会工作")
    pass
​
class Mother(object):
    fact='漂亮'
    money=90
    def cook(self):
        print("会做饭")
    pass
​
class Son(Father,Mother):
    pass
​
# 创建son的实例
s=Son()
s.cook()
s.work()
print(s.fact)
print(s.height)
print(s.money)

同时继承 Father类和 Mother类时，Father类在前，当属性和方法重复时，越往前优先级越高。

查看继承关系

print(Dog.__bases__)
print(Dog.__mro__)

3.3.多态

class Animal(object):
    def play(self):
        pass
​
class Tiger(Animal):
    def play(self):
        print("正在表演老虎后脚直立行走")
​
​
class Lion(Animal):
    def play(self):
        print("正在表演狮子跳火圈")
​
​
class Person(object):
    def show(self, a: Animal):
        print("动物表演开始了")
        a.play()
​
​
p = Person()
tiger = Tiger()
lion = Lion()
​
p.show(tiger)
p.show(lion)

4.扩展

4.1.slots

每个类都有实例属性。默认情况下Python⽤⼀个字典来保存⼀个对象的实例属性。所以我们在可以在运⾏时去设置任意的新属性。

所以，动态给类或者实例对象添加属性或方法，是非常灵活的。但与此同时，如果胡乱地使用，也会给程序带来一定的隐患，即程序中已经定义好的类，如果不做任何限制，是可以做动态的修改的。

Python 提供了 __slots__ 属性，通过它可以避免用户频繁的给实例对象动态地添加属性或方法。

class Dog(object):
    __slots__ = ["name","age"]
    
    def __init__(self,name,age):
        print("实例化")
        self.name=name
        self.age=age

__slots__ 只能限制为实例对象动态添加属性和方法，而无法限制动态地为类添加属性和方法。

4.2.类装饰器

类装饰器在内部的装饰函数是用__call__() 方法实现的。

class Logger(object):
    def __init__(self, path='out.txt'):
        self.path = path
    def __call__(self, func):
        def inner():
            log = func.__name__ + "执行"
            with open(self.path, 'a') as opened_file:
                opened_file.write(log + '\n')
            self.notify()
        return inner
    def notify(self):
        pass
​
@Logger()
def hello():
    pass
​
hello()

@Logger 的在这里的作用实际就是实例化一个fun对象（fun=Logger(fun)）