Python面向对象特性-阿里云开发者社区

1 面向对象之继承

1.1 继承的概念

生活中的继承，一般指的是子女继承⽗辈的财产。

拓展1：经典类或旧式类

不由任意内置类型派生出的类，称之为经典类。

class 类名:
    代码
    ......

拓展2：新式类

class 类名(object):
    代码

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承⽗类的所有属性和方法，具体如下：

# ⽗类A
class A(object):
    def __init__(self):
        self.num = 1
    def info_print(self):
        print(self.num)
# 子类B
class B(A):
    pass
result = B()
result.info_print() # 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

1.2 单继承

故事主线：一个煎饼果子⽼师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼果子的技术。师⽗要把这套技术传授给他的唯一的最得意的徒弟。

分析：徒弟是不是要继承师⽗的所有技术？

# 1. 师⽗类
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 2. 徒弟类
class Prentice(Master):
    pass
# 3. 创建对象daqiu
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu) 
# 5. 对象调用实例方法
daqiu.make_cake()

1.3 多继承

故事推进：daqiu是个爱学习的好孩子，想学习更多的煎饼果子技术，于是，在百度搜索到程序员，报班学习煎饼果子技术。

所谓多继承意思就是一个类同时继承了多个⽗类。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
   pass
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

注意：当一个类有多个⽗类的时候，默认使用第一个⽗类的同名属性和方法。

1.4 子类重写父类同名方法和属性

故事：daqiu掌握了师父和培训的技术后，自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 独创配方
class Prentice(School, Master):
     def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)

子类和⽗类具有同名属性和方法，默认使用子类的同名属性和方法。

1.5 子类调用父类的同名方法和属性

故事：很多顾客都希望也能吃到古法和oldlu的技术的煎饼果子。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
    print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
    def make_cake(self):
        # 如果是先调用了⽗类的属性和方法，⽗类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    # 调用⽗类方法，但是为保证调用到的也是⽗类的属性，必须在调用方法前调用⽗类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

1.6 多层继承

故事：N年后，daqiu⽼了，想要把所有技术传承给自己的徒弟。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
# 徒孙类
class Tusun(Prentice):
    pass
xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

1.7 super()调用父类方法

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(Master):
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        # 方法2.1
        # super(School, self).__init__()
        # super(School, self).make_cake()
        # 方法2.2
        super().__init__()
        super().make_cake()
class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    # 子类调用⽗类的同名方法和属性：把⽗类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
    # 一次性调用⽗类的同名属性和方法
    def make_old_cake(self):
        # 方法一：代码冗余；⽗类类名如果变化，这里代码需要频繁修改
        # Master.__init__(self)
        # Master.make_cake(self)
        # School.__init__(self)
        # School.make_cake(self)
        # 方法二: super()
        # 方法2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()
        # 方法2.2 super().函数()
        super().__init__()
        super().make_cake()
daqiu = Prentice()
daqiu.make_old_cake()

注意：使用super() 可以自动查找⽗类。调用顺序遵循 mro 类属性的顺序。比较适合单继承使用。

1.8 私有权限

1.8.1 定义私有属性和方法

在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。

故事：daqiu把技术传承给徒弟的同时，不想把自己的钱(2000000个亿)继承给徒弟，这个时候就要为钱这个实例属性设置私有权限。

设置私有权限的方法：在属性名和方法名前面加上两个下划线 __。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        # 定义私有属性
        self.__money = 2000000
    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
    School.__init__(self)
    School.make_cake(self)
# 徒孙类
class Tusun(Prentice):
    pass
daqiu = Prentice()
# 对象不能访问私有属性和私有方法
# print(daqiu.__money)
# daqiu.__info_print()
xiaoqiu = Tusun()
# 子类无法继承⽗类的私有属性和私有方法
# print(xiaoqiu.__money) # 无法访问实例属性__money
# xiaoqiu.__info_print()

注意：私有属性和私有方法只能在类里面访问和修改。

1.8.2 获取和修改私有属性值

在Python中，一般定义函数名 get_xx 用来获取私有属性，定义 set_xx 用来修改私有属性值。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class School(object): 
    def __init__(self):
        self.kongfu = '[oldlu煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        self.__money = 2000000
    # 获取私有属性
    def get_money(self):
        return self.__money
    # 修改私有属性
    def set_money(self):
        self.__money = 500
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)
    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
# 徒孙类
class Tusun(Prentice):
    pass
daqiu = Prentice()
xiaoqiu = Tusun()
# 调用get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
# 调用set_money函数修改私有属性money的值
xiaoqiu.set_money()
print(xiaoqiu.get_money())

2 面向对象-其他

2.1 面向对象三大特性

封装

将属性和方法书写到类的里面的操作即为封装
封装可以为属性和方法添加私有权限

继承

子类默认继承⽗类的所有属性和方法

子类可以重写⽗类属性和方法

多态

传入不同的对象，产生不同的结果

2.2 多态

2.2.1 了解多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

定义：多态是一种使用对象的方式，子类重写⽗类方法，调用不同子类对象的相同⽗类方法，可以产生不同的执行结果

好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

实现步骤：

定义⽗类，并提供公共方法

定义子类，并重写⽗类方法

传递子类对象给调用者，可以看到不同子类执行效果不同

2.2.2 体验多态

class Dog(object):
    def work(self): # ⽗类提供统一的方法，哪怕是空方法
        print('指哪打哪...')
class ArmyDog(Dog): # 继承Dog类
    def work(self): # 子类重写⽗类同名方法
        print('追击敌人...')
class DrugDog(Dog):
    def work(self):
        print('追查毒品...')
class Person(object):
    def work_with_dog(self, dog): # 传入不同的对象，执行不同的代码，即不同的work函数
        dog.work()
ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

2.3 类属性和实例属性

2.3.1 类属性

2.3.1.1 设置和访问类属性

类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。
类属性可以使用类对象或实例对象访问。

class Dog(object):
    tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth) # 10
print(wangcai.tooth) # 10
print(xiaohei.tooth) # 10

类属性的优点

类的实例记录的某项数据始终保持一致时，则定义类属性。
实例属性要求每个对象为其单独开辟一份内存空间来记录数据，而类属性为全类所共有，仅占用一份内存，更加节省内存空间。

2.3.1.2 修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

class Dog(object):
    tooth = 10
wangcai = Dog()
xiaohei = Dog()
# 修改类属性
Dog.tooth = 12
print(Dog.tooth) # 12
print(wangcai.tooth) # 12
print(xiaohei.tooth) # 12
# 不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性
wangcai.tooth = 20
print(Dog.tooth) # 12
print(wangcai.tooth) # 20
print(xiaohei.tooth) # 12

2.3.2 实例属性

class Dog(object):
    def __init__(self):
        self.age = 5
    def info_print(self):
        print(self.age)
wangcai = Dog()
print(wangcai.age) # 5
# print(Dog.age) # 报错：实例属性不能通过类访问
wangcai.info_print() # 5

2.4 类方法和静态方法

2.4.1 类方法

2.4.1.1 类方法特点

第一个形参是类对象的方法
需要用装饰器 @classmethod 来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以 cls 作为第一个参数。

2.4.1.2 类方法使用场景

当方法中需要使用类对象 (如访问私有类属性等)时，定义类方法
类方法一般和类属性配合使用

class Dog(object):
    __tooth = 10
    @classmethod
    def get_tooth(cls):
        return cls.__tooth
wangcai = Dog()
result = wangcai.get_tooth()
print(result) # 10

2.4.2 静态方法

2.4.2.1 静态方法特点

需要通过装饰器 @staticmethod 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
静态方法也能够通过实例对象和类对象去访问。

2.4.2.2 静态方法使用场景

当方法中既不需要使用实例对象(如实例对象，实例属性)，也不需要使用类对象 (如类属性、类方法、创建实例等)时，定义静态方法
取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个狗类，用于创建狗实例....')
wangcai = Dog()
# 静态方法既可以使用对象访问又可以使用类访问
wangcai.info_print()
Dog.info_print()

Python面向对象特性

1 面向对象之继承

1.1 继承的概念

1.2 单继承

1.3 多继承

1.4 子类重写父类同名方法和属性

1.5 子类调用父类的同名方法和属性

1.6 多层继承

1.7 super()调用父类方法

1.8 私有权限

1.8.1 定义私有属性和方法

1.8.2 获取和修改私有属性值

2 面向对象-其他

2.1 面向对象三大特性

2.2 多态

2.2.1 了解多态

2.2.2 体验多态

2.3 类属性和实例属性

2.3.1 类属性

2.3.1.1 设置和访问类属性

2.3.1.2 修改类属性

2.3.2 实例属性

2.4 类方法和静态方法

2.4.1 类方法

2.4.1.1 类方法特点

2.4.1.2 类方法使用场景

2.4.2 静态方法

2.4.2.1 静态方法特点

2.4.2.2 静态方法使用场景

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Python面向对象特性

1 面向对象之继承

1.1 继承的概念

1.2 单继承

1.3 多继承

1.4 子类重写父类同名方法和属性

1.5 子类调用父类的同名方法和属性

1.6 多层继承

1.7 super()调用父类方法

1.8 私有权限

1.8.1 定义私有属性和方法

1.8.2 获取和修改私有属性值

2 面向对象-其他

2.1 面向对象三大特性

2.2 多态

2.2.1 了解多态

2.2.2 体验多态

2.3 类属性和实例属性

2.3.1 类属性

2.3.1.1 设置和访问类属性

2.3.1.2 修改类属性

2.3.2 实例属性

2.4 类方法和静态方法

2.4.1 类方法

2.4.1.1 类方法特点

2.4.1.2 类方法使用场景

2.4.2 静态方法

2.4.2.1 静态方法特点

2.4.2.2 静态方法使用场景

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像