面向对象的晋级补充

时间:2019-10-11
本文章向大家介绍面向对象的晋级补充,主要包括面向对象的晋级补充使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

组合:

-就是一个类的对象具备某一个属性,该属性的值是指向另一个类的对象

组合用来解决类与类之间代码冗余的问题。

class Course:
    def __init__(self, name, period, price):
        self.name = name
        self.period = period
        self.price = price

    def tell_info(self):
        mag = f"""
        课程名:{self.name}
        课程周期:{self.period}
        课程价格:{self.price}"""
        print(mag)


class OldboyPeople:
    school = 'oldboy'

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


class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex, stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id = stu_id

    def choose_course(self):
        print(f'{self.name} is choosing course')


class Teacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        super().__init__(name,age,sex)
        self.level = level
        def score(self,stu,num):
            stu.score = num
            print(f'老师{self.name}为学生们{stu.name}打分{num}')
#创建课程
python = Course('python','5mouths',3000)
python.tell_info()
linux = Course('linux运维','5mouths',800)
linux.tell_info()

stu1 = OldboyStudent('tank',19,'male',1)
teal = Teacher('nick',18,'male',10)
#组合, 将学生对象的一个属性赋值为另一个对象
stu1.course = python
teal.course = linux
stu1.course.tell_info()
teal.course.tell_info()
        

总结:

    继承: 
        类与类的关系,一种什么是什么的关系,子类与父类是从属关系.
        
    组合:
        对象与对象的关系,一种什么有什么的关系,一个对象拥有另一个对象.
    组合:可以理解成多个人去造一个机器人,有的人造头、有的人造脚、有的人造手、有的人造躯干,大家都完工后,造躯干的人把头、脚、手拼接到自己的躯干上,因此一个机器人便造出来了
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def add_course(self, course_obj):
        self.course_list.append(course_obj)

    def tell_all_course(self):
        for course_obj in self.course_list:
            course_obj.tell_course_info()
            pass


class Teacher(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []


class Student(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []


class Course:
    def __init__(self, course_name, course_peirod, course_price):
        self.course_name = course_name
        self.course_peirod = course_peirod
        self.course_price = course_price

    def tell_course_info(self):
        print(f'''
        课程名称: {self.course_name}
        课程周期: {self.course_peirod}
        课程价格: {self.course_price}
        ''')


teal = Teacher('nick', 18, 'male')
stu1 = Student('小丁',20 , 'female')
python =  Course('python',6,2.0)
linux = Course('linux',6,1.0)

teal.add_course(python)
teal.add_course(linux)
teal.tell_all_course()

封装:

1.保护隐私

2.隔离复杂的过程,实现功能

提示:在编程语言里,对外提供的接口--入口,就是函数,称为接口函数,这与接口的概念还不一样,接口代表一组接口函数的集合体。
        封装指的是把一堆属性(特征与技能)封装到一个对象中.
        存数据的目的是为了取, 对象可以"."的方式获取属性.

        比喻: 对象就好比一个袋子, 袋子里面装一堆属性.

    2.为什么要封装?
        封装的目的为了方便存取,可以通过对象.属性的方式获取属性.

    3.如何封装
        特征: 变量 ---> 数据属性
        技能: 函数 ---> 方法属性

        在类内部,定义一堆属性(特征与技能).
        通过 对象.属性 = 属性值

一层封装:

类名 .+ 实例名.就是访问隐藏属性的接口

访问机制限制(多层封装):

在类内部定义,凡是以__开头的数据属性,方法属性都会被python内部隐藏,让外部不能·直接访问类内部的__开头的属性

注意:__x,时发生变形:_类名__x形式
class X:
    __n = 0 # 变形为self._A__X
    def __init__(self):
        self.__x =10
    def __foo(self):
        print('from X')
    def bar(self):
        self.__foo()
  # 只有在类内部才可以通过__foo的形式访问到.   

自动变形的特点:

  1. #### 类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果。
  2. #### 这种变形其实正是针对内部的变形,在外部是无法通过__x这个名字访问到的。
  3. 在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。

注意:对于这一层面的封装(隐藏),我们需要在类中定义一个函数(接口函数)在它内部访问被隐藏的属性,然后外部就可以使用了

要注意的问题是:

  1. 这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,

    变形的过程只在类的定义时发生一次,在定义后的赋值操作,不会变形

    在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的

class X:
    def __fa(self):
        print('from X')
    def test(self):
        self.__fa()
class B(X):
    def __fa(self):
        print('from B')

b = B()
b.test() 

from X

注:__名字,这种语法只在定义的时候才有变形的效果,如果类或对象已经产生了,就不会有变形的效果了

私有模块:python并不会真的阻止你访问私有的属性,模块也遵循这种约定,以单下划线开头,那么from module import *时不能被导入该变量

property:

property装饰器用于将被装饰的方法伪装成一个数据属性,在使用时可以不加括号而被直接使用。

class Foo:
    def func(self):
        pass
    @property
    def size(self):
        return 100
foo_obj = Foo()
print(foo_obj.size)
--100
#不加括号
property:
    1.什么是property
        python内置的装饰器, 主要是给类内部的方法使用.

    2.为什么要用property
        使用它的目的,是将类内部的方法 (def 方法名()) 变成了 (def 方法).
        在对象调用某个方法时,将对象.方法()变成对象.方法(看起来想一个普通的数据属性)

    3.如何使用property
        @property

property属性的定义和调用要注意一下几点:

  1. 定义时,在实例方法的基础上添加 @property 装饰器;并且仅有一个self参数

  2. 调用时,无需括号

多态:

  • 多态是在定义角度

  • 多态性是在调用角度(使用角度)

多态指的是一类事物有多种形态(一个抽象类有多个子类,因而多态的概念依赖与继承)

注意:多态与多态性是两种概念

多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。

在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息,不同的对象在接收时会产生不同的行为(即方法)。

也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

如:序列数据类型有多种形态:字符串,列表,元组

多态性的优点:

1.增加程序的灵活性

2.增加程序的可扩展性

抽象类:

-abc模块

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

python不会强制要求子类必须遵循父类的一套标准,所以出现抽象类

import abc
class File(metaclass=abc.ABCMeta):
    def click(selfself):
        pass
class Text(File):
    def click(self):
        print('open file')

class ExeFile(File):
    def click(self):
        print('execute file')

text = Text()

exe_file = ExeFile()
text.click()
exe_file.click()
多态的目的:
        多态也称之为多态性, 在程序中继承就是多态的表现形式.
        多态的目的是为了, 让多种不同类型的对象, 在使用相同功能的情况下,调用同一个名字的方法名.
        父类: 定义一套统一的标准.
        子类: 遵循父类统一的标准.
        多态的最终目的: 统一子类编写的规范, 为了让使用者更方便调用相同功能的方法

总结:

多态:同一种事物的多种形态,动物分为人类,猪类(在定义角度)

多态性:一种调用方式,不同的执行效果(多态性)

鸭子类型:

-在不知道当前对象是何物的情况下,但是你长的像鸭子,那你就是鸭子类型,

在python中,不推荐使用抽象类强制限制子类的定义,但是推荐类都遵循鸭子类型

继承:

-耦合性太高,程序的可扩展性差

鸭子类型:

-耦合度低,程序的可扩展性强

多态炫技:

str1 = '1234'
list1 = [1,2,3]
def LEN(d):
    return d.__len__()
print(LEN(str1))
print(LEN(list1))

原文地址:https://www.cnblogs.com/shaozheng/p/11655169.html