目录

组合 概念 目的 实现方式 封装 概念 目的 实现方式 访问限制 概念 目的 实现方式 Property 概念 目的 实现方式 多态 概念 目的 抽象类 概念 目的 实现方法 鸭子类型

组合

概念

组合指的是一个对象中的属性是另一个对象

目的

组合的目的和继承一样, 为了减少代码冗余

实现方式

# 1
class Other:
    def func(self):
        print('from other')


class Foo:
    def __init__(self):
        self.other = other()
        
     def func(self):
        self.other.func()
        
foo = Foo()
foo.func()  # from other

# 2
class Other:
    def func(self):
        print('from other')
        

class Foo:
    pass

foo = Foo()
other_obj = Other()

foo.func = other_obj.func
foo.func()  # from other

总结: 继承: 是一种xx是xx的关系(is-a) 组合: 是一种xx有xx的关系(has-a)

封装

概念

封装指的是把一系列属性(特征和技能)放到一个类中就构成了封装

存数据的目的是为了取, 对象可以通过 . 的方式获取属性

目的

封装的目的是方便取用, 对象可以通过 对象.属性 的方式获取属性

实现方式

定义类时, 把一系列属性(特征和技能)放到一个类中就构成了封装

访问限制

概念

在类内部, 凡是以__开头的属性都会被隐藏起来, 外部不能直接访问

目的

对重要或隐私数据获取的更加严谨, 进而保证了数据的安全 隐私属性可以通过在类内部封装一个接口, 在接口内做业务逻辑处理, 再把数据返回给调用者 注意: 在Python中, 不会强制限制属性的访问, 类内部__开头的属性, 只是做了一种变形, 若想访问, 调用变形后的名字即可

class Foo:
    __name = 'bigb'
    
    def __func(self):
        print('secret')


foo = Foo()

print(foo._Foo__name)  # bigb
foo._Foo__func()  # secret

实现方式

# 1
class PyMan:
    language = 'Python'

    def __init__(self, name, age, gender):
        self.__name = name
        self.__age = age
        self.__gender = gender

    # 打印用户信息接口
    def get_info(self):
        username = input('请输入用户名: ')
        password = input('请输入密码: ')

        if username == 'bigb' and password == '123':
            print(f'''
            姓名: {self.__name}
            年龄: {self.__age}
            性别: {self.__gender}
            ''')

    # 修改用户信息接口
    def set_info(self, name, age, gender):
        if not isinstance(name, str):
            raise TypeError
        if not isinstance(age, int):
            raise TypeError
        if not isinstance(gender, str):
            raise TypeError

        self.__name = name
        self.__age = age
        self.__gender = gender


bigb = PyMan('bigb', 18, 'male')
bigb.get_info()  
bigb.set_info()

# 2
class ATM:

    def __insert_card(self):
        print('插卡')

    def __input_pwd(self):
        print('输入密码')

    def __input_money(self):
        print('输入金额')

    def __get_monet(self):
        print('执行吐钱')

    def __print_bill(self):
        print('打印账单')

    def withdraw(self):
        self.__insert_card()
        self.__input_pwd()
        self.__input_money()
        self.__get_monet()
        self.__print_bill()
        print('取款程序执行完毕!')



atm = ATM()
atm.withdraw()

'''
插卡
输入密码
输入金额
执行吐钱
打印账单
取款程序执行完毕!
'''

Property

概念

Python内置的装饰器, 主要给内部的方法使用

目的

是将类内部的方法 def 方法名(): 变成了 def 方法: 在对象调用某个方法时, 将 对象.方法名() 变成 对象.方法名 , 使其看起来像一个普通的数据属

实现方式

@property

class People:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    @property
    def bmi(self):
        return self.weight / (self.height * self.height)


bigb = People('bigb', 70, 1.8)

# 如果不用@property, 则print(bigb.bmi())
print(bigb.bmi)

多态

概念

不同的 子类对象 调用 相同的父类 方法, 产生 不同的执行结果

以 继承 和 重新父类方法 为前提

是调用方法的技巧, 不会影响类的内部设计

目的

多态可以增加代码的灵活度

抽象类

概念

abc 模块

目的

强制在定义子类时必须定义和父类的相同的方法

实现方法

import abc

import abc


class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def drink(self):
        pass


class Pig(Animal):
    def eat(self):
        print('pig is eating...')


peppa = Pig()

TypeError: Can‘t instantiate abstract class Pig with abstract methods drink

父类方法被 @abc.abstractmethod 装饰后, 子类必须也有相同的方法, 否则会报错

鸭子类型

当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子 不关注类型, 只关注方法 继承: 耦合度高, 程序的可扩展性差 鸭子类型: 程序的可扩展性强

查看更多关于Python3 面向对象进阶的详细内容...