前言

在上一篇《Python面向对象编程-初级篇》中，主要介绍了面向对象相关概念、面向对象相关术语、获取或添加对象属性、魔法方法以及Python的内置属性，本篇内容则继续介绍面向对象进阶部分的内容：

• 面向对象的三大特性：封装、继承、多态
• 类中的三类变量：类变量、成员变量、局部变量
• 类中的私有方法和私有属性
• 类的三类方法：实例方法、类方法、静态方法

一、面向对象的三大特性：封装、继承、多态

1.封装

封装就是把内容封装到某个地方，后面再从某处调用被封装的内容

函数式编程的封装

def work(name, age, work):
    print(f"我叫{name}，我今年{age}岁了，我的工作是{work}")

def interest(name, age, interest):
    print(f"我叫{name}，我今年{age}岁了，我的爱好是{interest}")

def city(name, age, city):
    print(f"我叫{name}，我今年{age}岁了，我的家乡是{city}")

work('小明', 28, '司机')
interest('小明', 28, '滑雪')
city('小明', 28, '北京')

面向对象编程的封装

class Introduction(object):
    def __init__(self, name, age, city, work, interest)
        self.name = name
        self.age = age
        self.city = city
        self.work = work
        self.interest = interest

    def intro(self):
        print(f"我叫{self.name}，我今年{self.age}岁了，我的家乡是{self.city}，工作是{self.work}，爱好是{self.interest}")

intro1 = Introduction("小明", 28, "北京", "司机", "滑雪")
intro1.intro()
intro2 = Introduction("小华", 22, "上海", "学生", "篮球")
intro2.intro()

上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数较多，则需要多次复制粘贴；而对于面向对象，只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。使用面向对象的思想可以更好地模拟现实生活中的事物。

2.继承

通过继承创建的类称为子类或派生类，被继承的类称为基类、父类或超类，子类可以继承父类的内容，调用父类中的属性或方法。

1）子类继承父类

如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法，或者不重写父类的构造方法

class ParentObject(object):
    def __init__(self, height):
        self.name = "当当"
        self.age = 5

    def parent_func(self):
        print("这是父类中的方法")

class ChildObject(ParentObject):
    def child_func(self):
        print("这是子类中的方法")

child = ChildObject()
child.parent_func()  # 这是父类中的方法
child.child_func()  # 这是子类中的方法
print(ChildObject.__bases__)  # (<class '__main__.ParentObject'>,)

2）子类继承父类中的构造方法

如下案例：子类ChildObject继承了父类ParentObject，如果想要在子类的构造方法中继承父类构造方法中的属性，可以有以下几种写法：

1. ParentObject.__init__(self,height='115cm')
2. super().__init__(height='115cm')
3. super(ChildObject, self).__init__(height='115cm')

class ParentObject(object):

    def __init__(self, height):
        self.name = "当当"
        self.age = 5
        self.height = height

    def parent_func(self):
        print("这是父类中的方法")

class ChildObject(ParentObject):
    def __init__(self):
        # ParentObject.__init__(self,height='115cm')  # 子类继承父类的构造方法，写法一
        super().__init__(height='115cm')  # 子类继承父类的构造方法，写法二
        # super(ChildObject, self).__init__('115cm')  # 子类继承父类的构造方法，写法三

3）类的多继承：深度优先和广度优先

Python中一个子类可以继承多个父类，寻找方法有两种，分别是：深度优先（Python2）和广度优先（Python3）

在Python2中，经典类遵循的是深度优先的原则，新式类遵循的是广度优先的原则；而在Python3中，无论是经典类还是新式类，都遵循广度优先

class A(object):
    name = "Asia"
    def __init__(self):
        print("class A")

class B(A):
    def __init__(self):
        print("class B")

class C(A):
    def __init__(self):
        print("class C")

class D(B, C):  
# D类继承了B、C，会先从B类开始查找指定属性，B不存在时再从C开始查找，C也不存在时再从B的父类查找
    def __init__(self):
        print("class D")

obj = D()
print(obj.name) # Asia

由于D类继承了B、C，会先从B类开始查找name属性，B不存在，所以会再从C开始查找，由于C也不存在，所以会再从B的父类开始查找，最后在B的父类A中找到了name属性，打印结果为Asia。

4）子类重写父类方法

在子类中，使用与父类中相同的变量名或方法名，或重写父类的属性或方法

class Parent:
    def __init__(self):
        self.name = 'Lucy'

    def fun_a(self):
        print("this is a function in class Parent")

class Son(Parent):
    def __init__(self):
        super().__init__()
        self.name = 'Tom'  # 子类重写父类属性

    def fun_a(self):  # 子类重写父类方法
        print("this is a function in class Son")

son = Son()
print(son.name)  # Tom
son.fun_a()  # this is a function in class Son

3.多态

不同的子类对象，调用相同的父类方法，产生不同的结果，一种事物的多种体现形式，函数的重写其实就是多态的一种体现

class Animals(object):
    def talk(self):
        print("animals")

class Person(Animals):
    def talk(self):
        print("person")

class Cat(Animals):
    def talk(self):
        print("cat")

class Dog(Animals):
    def talk(self):
        print("dog")

Person().talk()  # person
Cat().talk()  # cat
Dog().talk()  # dog

如上图所示，Person、Dog、Cat分别继承了Animals类，但是分别重写了talk方法，当这三个类分别被调用时会执行自己类中所定义的talk方法，而非父类Animals中的talk方法

二、类变量、成员变量、局部变量

1.类变量

类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。可以由类名直接调用，也可由对象来调用。

# 类变量
class A:
    name = 'Tony'

    def fun_a(self):
        print('this is a test function in class A')

print(A.name)  # Tony
print(A().name)  # Tony

2.实例变量（成员变量）

在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的，在构造方法中以self. 开头来定义。实例变量只能通过对象来调用，不能通过类名调用。

# 实例变量（成员变量）
class B:
    def __init__(self):
        self.city = 'suzhou'  # 实例变量
        self.street = '松涛街'  # 实例变量
        # 在构造方法中提前声明了一个方法，这个方法中所包含的变量也属于成员变量
        self.vars()  
        
    def vars(self):
        self.home = "月亮湾壹号"
        self.house = "1幢一单元108"

print(B().city)  # suzhou
print(B().street)  # 松涛街
print(B().__dict__)  # {'city': 'suzhou', 'street': '松涛街', 'home': '月亮湾壹号', 'house': '1幢一单元108'}

3.局部变量

定义在方法中的变量，只作用于当前实例的类。如以下方法中的mobile就属于局部变量。

def info(self):
    self.number = 227  # 局部变量
    self.phone = 15252162666  # 局部变量

三、类中私有方法和私有属性

1.类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

# 私有属性
class ParentObject(object):
    mobile = 15252162666  # 类变量
    __private_mobile = 15252162666  # 私有变量

    def fun(self):
        print("打印私有变量{}".format(self.__private_mobile))

    def func(self):
        return self.__fun()

po = ParentObject()
po.fun()  # 打印私有变量15252162666

2.类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

def __fun(self):
    print("这是一个私有化方法")

def func(self):
    return self.__fun()

3.外部调用类中的私有属性或方法

通常私有属性和私有方法只能在类的内部被调用，外部是不可以调用的。但如果强行调用，也是可以的，相当于Python中开了个后门：

外部调用类的私有属性：对象名._类名__属性名

外部调用类的私有方法：对象名._类名__方法名

# 外部调用类的私有属性：对象名._类名__属性名
print(po._ParentObject__private_mobile)
# 外部调用类的私有方法：对象名._类名__方法名
po._ParentObject__fun()

四、类的三类方法：实例方法、类方法、静态方法

1.实例方法

第一个参数必须是实例对象，该参数一般约定为self，通过它来传递实例的属性和方法（也可以传类的属性和方法），只能由实例对象调用

# 实例方法
class Example:
    def fun_a(self):
        print("这是一个实例方法")
        
# 调用实例方法，只能由实例对象调用
ex = Example()
ex.fun_a()  # 这是一个实例方法

2.类方法

使用装饰器@classmethod，第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法），类和实例对象都可以调用

@classmethod
def fun_b(self):
    print("这是一个类方法")
    
# 调用类方法，实例对象和类名都可以调用，使用类名直接调用时，不会执行类中的构造方法
ex.fun_b()  # 这是一个类方法
Example.fun_b()  # 这是一个类方法

注：使用类名直接调用时，不会执行类中的构造方法

3.静态方法

使用装饰器@staticmethod修饰，参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法，一般用于和类本身无太多关联但又会绑定在类中的场景（不可使用类中的属性和方法），如获取时间等等。类和实例对象都可以调用

@staticmethod
def fun_c():
    print("这是一个静态方法")
    
# 调用静态方法，实例对象和类名都可以调用，不能使用类或实例的任何属性和方法
ex.fun_c()  # 这是一个静态方法
Example.fun_c()  # 这是一个静态方法

小结