标签：class   foo   一个   elf   形式   如何   ==   each   def   

组合

什么是组合

? 组合指的是一个对象中的属性，该属性的值指向的是另一个对象。

组合的作用

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

如何使用组合

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

class Teacher(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)

class Student(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

    def tell_birth(self):
        print(f‘‘‘
        ===出生年月日===
        年：{self.year}
        月：{self.month}
        日：{self.day}‘‘‘)

tea1=Teacher(‘tank‘,17,‘male‘)
date_obj=Date(2002,1,1)
tea1.date=date_obj#将date对象赋值到tea1对象的date属性中
tea1.date.tell_birth()
‘‘‘
===出生年月日===
        年：2002
        月：1
        日：1‘‘‘

总结

继承

? 类与类的关系，一种什么是什么的关系，子类与父类是从属关系。

组合

? 对象与对象的关系，一种什么有什么的关系，一个对象拥有另一个对象

封装

什么是封装

? 比喻：

? 封：比如把一个袋子封起来

? 装：比如把一堆小猫小狗装到袋子类

? 封装指的是把一堆属性封装到一个对象中

? 存数据的目的是为了取，对象可以“.”的方式获取属性

? 比喻：

? 对象就好比一个袋子，袋子里面装着一堆属性

为什么封装

? 封装的目的是为了方便存取，可以通过对象.属性的方式获取属性

如何封装

? 特征：变量---》数据属性

? 技能：函数---》方法属性

? 在类内部，定义一堆属性

? 通过对象.属性=属性值

访问限制机制

什么是访问限制机制

? 在类内部定义，凡是以__开头的数据属性与方法属性，都会被python内部隐藏起来，让外部不能直接访问类内部的__开头的属性，比如：__name=‘tank‘

访问限制机制的目的

? 一堆隐私的属性与不能被外部轻易访问的属性，可以隐藏起来，不被外部直接调用

? 好处：

? 对重要数据获取的逻辑更加严谨，进而保证了数据的安全。

? 接口：

? 隐私属性可以通过封装一个接口，在接口内做业务逻辑的处理，再把数据返回给调用者

? 注意：

? 在python中，不会强制限制属性的访问，在类内部__开头的属性，只是做了一种变形，若想直接访问，调用变形后的名字即可。

class Foo:
    __name=‘tank‘#-->_类名__属性名

class Foo:
    __name=‘tank‘

    def __run(self):
        print(‘running....‘)

    def get_name(self):
        return self.__name

    def set_name(self):
        self.__name=‘jason‘

foo=Foo()
print(foo.get_name())#tank
print(foo._Foo__name)#tank
foo.set_name()
print(foo.get_name())#jason

class ATM:
    def __insert_card(self):
        print(‘插卡‘)

    def __input_pwd(self):
        print(‘密码验证‘)

    def withdraw(self):
        self.__input_pwd()
        self.__insert_card()

atm=ATM()
atm.withdraw()
‘‘‘
密码验证
插卡‘‘‘

property

什么是property

? python内置的装饰器，主要是给类内部的方法使用

为什么要用property

? 使用它的目的，是将类内部的方法def 方法名()变成了def 方法名。

? 在对象调用某个方法时，将对象.方法（）变成对象.方法（看起来像一个普通的数据属性）

如何使用property

? @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)


p=People(‘name‘,200,1.8)
print(p.bmi)#61.72839506172839
# 注意：不能对被装饰的方法属性修改

#了解 若真的通过此方法修改属性，可以通过另一种方式修改
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)

    @property
    def get_name(self):
        return self.name

    @get_name.setter
    def set_name(self,val):
        self.name=val

    @get_name.deleter
    def del_name(self):
        del self.name

p=People(‘jason‘,200,1.8)
print(p.get_name)#jason
p.set_name=‘bank‘
print(p.get_name)#bank
del p.del_name#删除name这个属性
print(p.get_name)

多态

什么是多态

? 多态指的是同一种事物的多种形态。

多态的目的

? 多态也称之为多态性，在程序中继承就是多态的表现形式

? 多态的目的就是为了，让多种不同类型的对象，在使用相同功能的情况下，调用同一个名字的方法名

? 父类：定义一套统一的标准

? 子类：遵循父类统一的标准

? 多态的最终目的：统一子类编写的规范，为了让使用者更方便调用相同功能的方法

如何实现

class Animal:
    def eat(self):
        pass

    def drink(self):
        pass

    def speak(self):
        pass

class Pig(Animal):
    def eat(self):
        print(‘猪仔吃点‘)
        pass

    def drink(self):
        pass

    def speak(self):
        print(‘哼哼哼‘)
        pass

class Cat(Animal):
    def eat(self):
        print(‘猫吃点‘)
        pass

    def drink(self):
        pass

    def speak(self):
        print(‘喵喵喵喵‘)
        pass

pig=Pig()
cat=Cat()

pig.speak()#哼哼哼
cat.speak()#喵喵喵喵

抽象类

什么是抽象类

abc模块 abstract_class

目的

? 强制子类必须遵循父类的一套标准

如何使用

import abc


class Animal(metaclass=abc.ABCMeta):

    # 吃
    @abc.abstractmethod
    def eat(self):
        pass

    # 喝
    @abc.abstractmethod
    def drink(self):
        pass

    # 叫
    @abc.abstractmethod
    def speak(self):
        pass


# 猪
class Pig(Animal):
    # 吃
    def eat(self):
        print(‘猪在吃饭‘)
        pass

    # 喝
    def drink(self):
        pass


    def speak(self):
        print(‘哼哼哼~~~‘)


    # 派生
    def run(self):
        pass

鸭子类型

什么是鸭子类型

? 在不知道当前对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型.在python中,不推荐使用抽象类强制限制子类的定义,但是推荐类都遵循鸭子类型.

继承：

? 耦合性太高，程序的可扩展性差

鸭子类型：

? 耦合性低，程序的可扩展性强

多态炫技

# 猪
class Pig:
    # 吃
    def eat(self):
        print(‘猪在吃饭‘)
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print(‘哼哼哼~~~‘)


# 猫
class Cat:
    # 吃
    def eat(self):
        print(‘猫在吃饭‘)
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print(‘喵喵喵~~‘)

# 狗
class Dog:
    # 吃
    def eat(self):
        print(‘狗在吃饭‘)
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print(‘汪汪汪~~~‘)

dog = Dog()
cat = Cat()
pig = Pig()

def BARK(animal):
    animal.speak()

BARK(dog)
BARK(cat)
BARK(pig)

封装 多态

标签：class   foo   一个   elf   形式   如何   ==   each   def   

原文地址：https://www.cnblogs.com/zqfzqf/p/12578141.html