Python面向对象,全栈开发

By admin in 4858.com on 2019年3月27日

1.
怎样是整合

面向对象学习目录

一连介绍

持续指的是类与类之间的关联,是一种怎么着是怎么着的涉嫌,效用之一正是用来消除代码重用难题。
继承是一种创立新类的主意,在python中,新建的类能够继续二个或四个父类,父类又可称为基类或超类,新建的类称为派生类或子类

一 、类的三结合

壹 、什么是整合

  组合:描述的是类与类之间的关系,是一种何等有怎么样关系
  二个类爆发的靶子,该对象具备叁特品质,那些性情的值是根源于其它1个类的指标

二 、什么是三番五次(回看一下)

  接二连三:描述的是类与类之间,什么是哪些的关系

叁 、组合的职能

  化解代码冗余

来看叁个实例子:

class Equip: #武器装备类
  def fire(self):
    print('release Fire skill')

class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
  camp='Noxus'
  def __init__(self,nickname):
    self.nickname=nickname
    self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性

r1=Riven('锐雯雯')
r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

总结:

构成与持续都是一蹴而就地选拔已有类的财富的主要方法。但是互相的概念和行使意况皆分歧,怎么采用依然看大家温馨

一 、继承的艺术

  通过一而再建立了派生类与基类之间的涉及,它是一种’是’的关联,比如白马是马,人是动物。

当类之间有那多少个等同的作用,提取这么些共同的效应做成基类,用持续比较好,比如老师是人,学生是人

Python面向对象,全栈开发。贰 、组合的格局

  用结合的点子建立了类与重组的类之间的涉嫌,它是一种‘有’的涉及,比如教师有生日,助教教python和linux课程,教授有学员s壹 、s二 、s3…

当类之间有分明差别,并且较小的类是较大的类所供给的机件时,用结合相比较好

 

    组合指的是某二个对象具备七个天性,该属性的值是此外1个类的目的

1 面向对象介绍

python 中分成单继承和多继承

python中类能够继续八个类.

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2):  # python支持多继承,用逗号分隔开多个继承的类
    pass

翻开继承的类:

res=SubClass2.__bases__
print(res)
#__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类

输出:
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

二 、类的卷入

一 、什么是封装     

    封装正是把一堆属性存起来,封的概念就把那几个属性给隐蔽起来
    强调:封装单从字面意思去看无差异隐藏,但骨子里封装相对不是单纯意义的隐蔽

贰 、封装的目标

    壹 、封装数据属性的目标:把数量属性封装起来,然后要求开辟接口给类外部的使用者利用,好处是
  我们得以在接口之上添加控制逻辑,从而严酷空间访问者对品质的操作

    二 、封装函数属性的目标:为了隔绝复杂度
    封装的顶点奥义:鲜明地方分内外,对外是藏匿的,对内是开放的

③ 、如何用包装

  怎样把品质隐藏起来,就在性质前边加上__(双下划线)初阶(注意不要加__结尾)
  注意:
    ① 、其实那种隐形只是一种语法上的变形,对外不对内
  为2本性能名加__千帆竞发(注意不要加__末尾),会在类定义阶段将属性名统一变形:_温馨的类名__属性名

    贰 、那种语法意义上变形,只在类定义阶段发生三回,类定义之后,新增的__发端的习性都未曾变形的功用

    ③ 、假若父类不想让子类覆盖本人的办法,能够在点子名前加__开头

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__x都会在类定义时自动变形成:_类名__x的形式:

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的,
#这种,在外部是无法通过__x这个名字访问到。

四 、 封装不是唯有意义的藏身

  封装的真谛在于显明所在分内外,封装的品质能够间接在其间采纳,而不能够被外表间接利用,然则定义属性的目标究竟是要用,外部要想用类隐藏的本性,要求我们为其开辟接口,让外部能够直接地用到大家隐藏起来的质量,这那样做的意义何在???

  壹 、封装数据:将数据隐藏起来那不是指标。隐藏起来然后对外提供操作该数量的接口,然后我们得以在接口附加上对该多少操作的限制,以此形成对数据属性操作的严控。

class Teacher:
    def __init__(self,name,age):
        # self.__name=name
        # self.__age=age
        self.set_info(name,age)

    def tell_info(self):
        print('姓名:%s,年龄:%s' %(self.__name,self.__age))
    def set_info(self,name,age):
        if not isinstance(name,str):
            raise TypeError('姓名必须是字符串类型')
        if not isinstance(age,int):
            raise TypeError('年龄必须是整型')
        self.__name=name
        self.__age=age

t=Teacher('duoduo',18) #没封装前,对象可以随意的改变属性
t.tell_info()                   #封装后,只能操作设计者让你操作的地方
t.set_info('qianduoduo',19)
t.tell_info()    

  二 、封装方法:目的是割裂复杂度

包装方法举例: 

1.
你的人身没有一处不反映着包裹的概念:你的骨血之躯把膀胱尿道等等那一个尿的功能隐藏了四起,然后为您提供一个尿的接口就能够了(接口正是你的。。。,),你总不能够把膀胱挂在身体外面,上厕所的时候就跟外人炫耀:hi,man,你瞅小编的膀胱,看看自身是怎么尿的。

2.
电视机本人是一个黑盒子,隐藏了有着细节,不过毫无疑问会对外提供了一堆按钮,那几个按钮也多亏接口的定义,所以说,封装并不是一味意义的隐藏!!!

唤醒:在编制程序语言里,对外提供的接口(接口可分晓为了3个进口),能够是函数,称为接口函数,那与接口的概念还区别,接口代表一组接口函数的集合体。

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

 

 

2.
为啥要用组合

2
类、实例、属性、方法详解

经典类和新颖类

1.唯有在python第22中学才分新式类和经文类,python3中集合都以最新类
2.在python第22中学,没有显式的继承object类的类,以及该类的子类,都以经典类
3.在python第22中学,显式地声称继承object的类,以及该类的子类,都以流行类
4858.com ,3.在python3中,无论是不是继承object,都暗中认可继承object,即python3中有着类均为新式类

提醒:借使没有点名基类,python的类会暗许继承object类,object是富有python类的基类,它提供了有的科学普及方式(如str)的实现。

res=ParentClass1.__bases__
print(res)
# 输出:
(<class 'object'>,)

在支付顺序的进度中,假使我们定义了3个类A,然后又想新确立别的二个类B,不过类B的大部内容与类A的相同时

咱俩不容许从头起头写二个类B,那就用到了类的持续的概念。

通过一连的方法新建类B,让B继承A,B会‘遗传’A的装有属性(数据属性和函数属性),达成代码重用
在不借助于继承属性的场合下,子类在调用父类的性质时,能够直接通过函数调用的艺术调用父类的习性:

class ParentClass: #定义父类
    def __init__(self,name,age):
        self.name=name
        self.age=age
class SubClass(ParentClass): 
    def __init__(self,name,age,hobby,title):
        ParentClass.__init__(self,name,age) # 直接以函数的方式调用父类的属性
        self.hobby=hobby
        self.title=title

obj=SubClass('tom',22,'reading','Student')
print(obj.__dict__)

留意:类的性质引用,会先从实例中找,然后去类中找,然后再去父类中找…直到最一级的父类。

 

    通过为某七个指标添加属性(属性的值是此外一个类的目的)的不二法门,能够直接地将多个类关联/整合/组合到一起

3
面向进程与面向对象进一步相比较

组合

构成指的是,在3个类中以其余多少个类的指标作为数据属性,称为类的构成
组合与继承都以卓有成效地动用已有类的资源的最重要形式。可是双方的定义和使用情状皆不一样:

1.接续的法门

透过一而再建立了派生类与基类之间的涉嫌,它是一种’是’的涉及,比如白马是马,人是动物。

当类之间有过多一模一样的职能,提取这个共同的功能做成基类,用一连相比较好,比如老师是人,学生是人

2.重组的艺术

用结合的法子确立了类与构成的类之间的关系,它是一种‘有’的涉嫌,比如教师有生日,教师教python和linux课程,教授有学生s一 、s② 、s3…

示例:

# coding=utf-8

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

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('%s %s %s' %(self.name,self.period,self.price))

class Teacher(People):
    def __init__(self,name,age,sex,job_title):
        People.__init__(self,name,age,sex)
        self.job_title=job_title
        self.course=[]
        self.students=[]


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


egon=Teacher('egon',18,'male','advance')
s1=Student('bob',18,'female')

python=Course('python','3mons',3000.0)
linux=Course('linux','3mons',3000.0)

#为老师egon和学生s1添加课程
egon.course.append(python)
egon.course.append(linux)
s1.course.append(python)

#为老师egon添加学生s1
egon.students.append(s1)


#使用
for obj in egon.course:
    obj.tell_info()
print(egon.__dict__)

输出结果:

python 3mons 3000.0
linux 3mons 3000.0
{'name': 'egon', 'age': 18, 'sex': 'male', 'job_title': 'advance', 'course': [<__main__.Course object at 0x000000410AF46CC0>, <__main__.Course object at 0x000000410AF46CF8>], 'students': [<__main__.Student object at 0x000000410AF46C88>]}

    从而裁减类与类之间代码冗余

4 类与对象

再三再四达成的规律

① 、继承顺序
* python 类能够接二连三多少个类,java和C#中则只可以继续三个类
* Python
的类假诺后续了八个类,那么其寻找父类的逐一有两种:深度优先广度优先
* 当类是经典类时,多三番肆次意况下,会依据深度优先的章程查找
* 当类是最新类时,多接二连三情状下,会依据广度优先的方法查找
引进使用新式类,假诺当前类如故父类继承了object类,那么该类就是1个新式类,不然正是经典类。(经典类之存在于python2中)

二 、继承原理(python怎么样兑现的存在延续)
python实现两次三番的原理是:
对于定义的每二个类,python都会总计出2个艺术分析顺序(MRO)列表,那一个MRO列表正是一个差不离的具备基类的线性顺序表。

class A:
    pass

class B(A):
    pass

class C:
    pass

class D(C,B):
    pass

obj=D()
print(D.mro())

# 输出列表:
[<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

为了贯彻三番五次,python会在MRO列表上从左到右开始查找基类,直到找到第③个门户相当那么些特性的类甘休。
而这一个MRO列表的结构是通过二个C3线性化算法来促成的。大家不去追究这一个算法的数学原理,它其实便是统一全数父类的MRO列表并遵从如下三条轨道:

  • 子类会先于父类被检查
  • 三个父类会依照它们在列表中的顺序被检查
  • 设若对下2个类存在多少个法定的精选,选拔第二个父类

3.
怎么样用整合

5
属性查找与绑定方法

子类中调用父类的办法

① 、通过点名父类方法名的法门去调用。(不利用接二连三的习性)
② 、通过应用super()

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就相当于实例本身, 在python3中super()等同于super(Subway,self)
        super().__init__(name,speed,load,power)   # 调用父类的init方法.
        self.line=line

注意:
当你利用super()函数时,Python会在MRO列表上接轨查找下五个类。只要每一种重定义的主意统一选取super()并只调用它一遍,那么控制流最后会遍历完全体MRO列表,每一种方法也只会被调用贰遍(注意留心留心:使用super调用的享有属性,都以从MRO列表当前的地方以后找,千万不要通过看代码去找继承关系,一定要看MRO列表)

 

6 小结

绑定方法与非绑定方法

类中的函数能够定义为两大类,一种是绑定方法,另一种是非绑定方法。

一 、绑定方法:绑定给什么人,哪个人来调用就活动将它本身作为第二个参数字传送入:
  – 绑定到类的点子:用classmethod装饰器装饰的主意。
为类量身定制,自动将类当作第③个参数字传送入。(其实对象也可调用,但仍将类当作第二个参数字传送入)
  – 绑定到对象的法子:没有被其余装饰器装饰的办法。、
为对象量身定制对象,自动将目的当作第四个参数字传送入(属于类的函数,类能够调用,不过必须遵照函数的平整来,没有机关传值那么一说)

构成与后续都以有效地利用已有类的能源的基本点情势。可是两者的定义和平运动用情况皆区别,

7 继承与派生

贰 、 非绑定方法:用staticmethod装饰器装饰的不二法门

不与类或对象绑定,类和目的都能够调用,不过尚未自行传值那么一说。就是五个无独有偶工具而已。在非绑定方法中不须求(不会自动传值)传入对象和类,只是履行函数成效。

 > 注意:与绑定到对象方法区分开,在类中直接定义的函数,没有被任何装饰器装饰的,都是绑定到对象的方法,可不是普通函数,对象调用该方法会自动传值,而staticmethod装饰的方法,不管谁来调用,都没有自动传值一说。

 

8 组合

1.继承的方式

9 抽象类

 

10 多态

因此接二连三建立了派生类与基类之间的涉及,它是一种’是’的关联,比如白马是马,人是动物。

11 封装

 

12
绑定方法与非绑定方法

当类之间有成都百货上千均等的功用,提取这么些共同的功能做成基类,用持续比较好,比如老师是人,学生是人

13 内置方法(上)

 

14
内置方法(中)之描述符

2.结合的艺术

15 内置方法(下)

 

16 元类

用结合的点子确立了类与重组的类之间的涉及,它是一种‘有’的涉及,比如教师有生日,教授教python和linux课程,教师有学生s壹 、s贰 、s3…


 

结缘与重用性

  软件重用的首要形式除了继续之外还有其它一种办法,即:组合

  组合指的是,在三个类中以别的3个类的靶子作为数据属性,称为类的整合

>>> class Equip: #武器装备类... 
            def fire(self):... 
                print('release Fire skill')...

>>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类... 
            camp='Noxus'
            ... 
            def __init__(self,nickname):
                ... 
                self.nickname=nickname
                ... 
                self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
            ...

>>> r1=Riven('锐雯雯')
>>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

 

  组合与继承都以实惠地应用已有类的财富的关键艺术。不过两岸的概念和采用情状皆不一样,

1.继承的主意

  通过持续建立了派生类与基类之间的关联,它是一种’是’的关系,比如白马是马,人是动物。

  当类之间有更仆难数等同的机能,提取那几个共同的机能做成基类,用一连相比好,比如老师是人,学生是人

2.结合的章程

  用整合的格局确立了类与重组的类之间的涉及,它是一种‘有’的关联,比如教授有生日,教师教python和linux课程,教师有学员s壹 、s二 、s3…

 

以身作则:继承与构成

 1 class People:
 2     def __init__(self,name,age,sex):
 3         self.name=name
 4         self.age=age
 5         self.sex=sex
 6 
 7 class Course:
 8     def __init__(self,name,period,price):
 9         self.name=name
10         self.period=period
11         self.price=price
12     def tell_info(self):
13         print('<%s %s %s>' %(self.name,self.period,self.price))
14 
15 class Teacher(People):
16     def __init__(self,name,age,sex,job_title):
17         People.__init__(self,name,age,sex)
18         self.job_title=job_title
19         self.course=[]
20         self.students=[]
21 
22 
23 class Student(People):
24     def __init__(self,name,age,sex):
25         People.__init__(self,name,age,sex)
26         self.course=[]
27 
28 
29 egon=Teacher('egon',18,'male','沙河霸道金牌讲师')
30 s1=Student('牛榴弹',18,'female')
31 
32 python=Course('python','3mons',3000.0)
33 linux=Course('python','3mons',3000.0)
34 
35 #为老师egon和学生s1添加课程
36 egon.course.append(python)
37 egon.course.append(linux)
38 s1.course.append(python)
39 
40 #为老师egon添加学生s1
41 egon.students.append(s1)
42 
43 #使用for obj in egon.course:
44 obj.tell_info()

 

总结:

  当类之间有家喻户晓不同,并且较小的类是较大的类所急需的组件时,用结合比较好

 

4858.com 14858.com 2

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,score=0):
        OldboyPeople.__init__(self,name,age,sex)
        self.score = score
        self.courses=[]

    def choose_course(self):
        print('%s choosing course' % self.name)

    def tell_all_course(self):
        print(('学生[%s]选修的课程如下' %self.name).center(50,'='))
        for obj in self.courses:
            obj.tell_info()
        print('='*60)

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        OldboyPeople.__init__(self,name,age,sex)
        self.level=level
        self.courses=[]

    def score(self,stu,num):
        stu.score=num

    def tell_all_course(self):
        print(('老师[%s]教授的课程如下' %self.name).center(50,'*'))
        for obj in self.courses:
            obj.tell_info()
        print('*'*70)

class Course:
    def __init__(self,c_name,c_price,c_period):
        self.c_name = c_name
        self.c_price = c_price
        self.c_period = c_period

    def tell_info(self):
        print('<课程名:%s 价钱:%s 周期:%s>' %(self.c_name,self.c_price,self.c_period))

# 创建课程对象
python=Course('python全栈开发',1900,'5mons')
linux=Course('linux架构师',900,'3mons')


stu1=OldboyStudent('刘二蛋',38,'male')
stu1.courses.append(python)
stu1.courses.append(linux)
# print(stu1.courses)
stu1.tell_all_course()


tea1=OldboyTeacher('egon',18,'male',10)
tea1.courses.append(python)
# print(tea1.courses)
tea1.tell_all_course()

View Code

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有