面向对象设计,Python面向对象编程
分类:计算机编程

由此多少个函数式编号演进,驾驭面向对象设计

Python面向对象编制程序

面向进程 VS 面向对象

面向进度的次序设计的大旨是经过(流水生产线式思维卡塔 尔(阿拉伯语:قطر‎,进程即化解难点的步子,面向进程的陈设就好比精心设计好一条流水线,寻思周详哪一天处理什么事物。

可取是:十分大的猛跌了写程序的复杂度,只须要顺着要试行的步调,堆集代码就能够。

弱点是:黄金时代套流水生产线可能流程正是用来消除八个难点,代码一着不慎满盘皆输。

行使场景:后生可畏旦达成人中学央非常少改动的情景,知名的例子有Linux內核,git,甚至Apache HTTP Server等。

 

面向对象的次序设计的着力是指标(上天式思维卡塔 尔(英语:State of Qatar),要知道对象为啥物,必需把温馨正是上天,上天眼里俗世存在的万物皆为目的,不设有的也得以成立出来。面向对象的前后相继设计好譬如来设计西游记,释尊要缓和的难题是把经书传给东土大唐,如来佛想了想化解那么些题目亟需三个人:唐三藏,沙僧,猪悟能,美猴王,各类人都有各自的特点和技能(那便是指标的概念,特征和技艺分别对应对象的性质和艺术卡塔尔国,然则那并欠风趣,于是释尊又布署了一堆妖妖精怪,为了制止师傅和门徒几人在取经路上被搞死,又布置了一批神明避风挡雨,这么些都以目的。然后取经开头,师傅和入室弟子三个人与妖鬼怪怪神明相互缠不屑一顾着直到最后拿到真经。释尊根本不会管师傅和门生多人根据什么样流程去取。

面向对象的次序设计的

可取是:化解了程序的扩大性。对某一个指标单独校订,会登时反映到全系列统中,如对游乐中壹职员参数的特色和技术纠正都超级轻便。

劣点:可控性差,非常的小概向面向进度的次第设计流水生产线式的能够很精准的预测难题的管理流程与结果,面向对象的顺序后生可畏旦最初就由对象时期的竞相解决难点哪怕是天神也力不胜任预测最后结果。于是大家常常来看三个戏耍人某风姿罗曼蒂克参数的改革极有超级大恐怕诱致阴霸的本事现身,一刀砍死3个人,这几个游乐就失衡。

使用途景:需要平常转移的软件,平常需求的生萨格勒布汇聚在客户层,互连网接收,集团中间软件,游戏等都以面向对象的顺序设计大显神通的好地方。

在python 中面向对象的次第设计而不是成套。

面向对象编程能够使程序的珍爱和强盛变得更简约,何况能够大大提升程序开拓功用,此外,基于面向对象的程序能够使它人越是便于明白您的代码逻辑,进而使集体开辟变得更从容。

刺探部分名词:类、对象、实例、实例化

类:具备同等特征的少年老成类东西(人、狗、森林之王)

目标/实例:具体的某一个东西(隔壁阿花、楼下旺财卡塔 尔(英语:State of Qatar)

实例化:类——>对象的长河

def01.py

面向对象的编制程序发生的历史由来:由于面向进程编制程序在结构系统时,不能够减轻重用,维护,扩充的主题素材,何况逻辑过于复杂,代码晦涩难懂,因而,大家开端想能否让Computer直接模拟现实的条件,以人类解决难点的方式,思路,习于旧贯和步骤来设计相应的应用程序。于是,面向对象的编制程序观念就生出了本章中,大家重要介绍面向对象编制程序(OOP, object-oriented

初识类和对象

python中整整皆为目的,类型的原形正是类

>>> dict #类型dict就是类dict
<class 'dict'>
>>> d=dict(name='eva') #实例化
>>> d.pop('name') #向d发一条消息,执行d的方法pop
'eva'

从地方的事例来看,字典便是意气风发类数据构造,笔者一说字典你就精通是特别用{}表示,里面由k-v键值没有错东西,它还富有部分增加和删除改查的章程。但是本身一说字典你能精通字典里实际存了如何内容么?无法,所以我们说对于二个类来讲,它具备相似的性状属性和艺术。

而现实的{'name':'eva'}这一个字典,它是一个字典,能够使用字典的具有办法,而且个中有了切实的值,它正是字典的三个对象。对象便是早已确实存在的某三个具体的村办。

 

再举一个别的的例子,通俗一点,比方你现在有八个动物公园,你想描述那些动物公园,那么动物公园里的每大器晚成种动物正是三个类,苏门答腊虎、天鹅、鳄鱼、熊。他们都有同等的性质,比如身体高度体重出生时间和种类,还或许有各类动作,举例鳄鱼会游泳,天鹅会飞,大虫会跑,熊会吃。

但是那个扁担杜洞尕啥的都不是绘影绘声的某一只,而是生龙活虎类动物。即便她们都有身体高度体重,可是你却从不艺术规定那些值是多少。即使那时候给您二头具体的山尊,而你还未有死,那你就能够给她量量身体高度称称体重,那几个数值是否就改为现实的了?那么具体的那贰只苏门答腊虎正是二个具体的实例,也是三个指标。不独有那五头,其实每多只具体的森林之王皆有协和的身高体重,那么每两只老虎都以老虎类的二个对象。

在python中,用变量表示特征,用函数表示手艺,因此具有相通特征和本领的朝气蓬勃类东西正是‘类’,对象是则是这意气风发类东西中实际的八个。

 1 dog1 = {
 2     'name':'元昊',
 3     'gender':'母',
 4     'type':'藏獒'
 5 }
 6 dog2 = {
 7     'name':'李李',
 8     'gender':'公',
 9     'type':'腊肠'
10 }
11 
12 def jiao(dog):
13     print('一条狗[%s],汪汪'%dog['name'])
14 
15 def yaoren(dog):
16     print('一条狗[%s]正在咬人'%dog['type'])
17 
18 jiao(dog1)
19 yaoren(dog1)
20 yaoren(dog2)

programming卡塔 尔(英语:State of Qatar)的编制程序观念。首先介绍面向对象编制程序的朝气蓬勃对基本概念、观念、特点以至选取的第一指标。然后商量类的始建以至使用细则和章程,类性质、对象的开头化等等。

类的相干知识

 def02.py

  1. 面向进程和面向对象编制程序的基本概念

初识类

 6 
 7 def dog():
 8     def jiao(dog):
 9         print('一条狗[%s],汪汪'%dog['name'])
10 
11     def yaoren(dog):
12         print('一条狗[%s]正在咬人'%dog['type'])
13 
14     dog1 = {
15         'name': '元昊',
16         'gender': '母',
17         'type': '藏獒',
18         'jiao':jiao,
19         'yaoren':yaoren
20     }
21     return dog1
22 
23 d1 = dog()
24 d1['jiao'](d1)

核激情想:面向对象的编制程序的主要观念是把构成难点的各种事物分解成各样对象,创立目的的指标不是为着实现三个步骤,而是为了描述叁个东西在消除难题的长河中经验的步子和行事。对象作为程序的大旨单位,将次第和数目封装当中,以升高程序的重用性,灵活性和可扩充性。类是创设对象的模版,八个类可以创设多少个对象。对象是类的实例化。

声明

#声明函数
def functionName(args):
     '函数文档字符串'
      函数体 

#声明类
'''
class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
class Data:
    pass

#------------------------------------------------------------------------------
class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法,也叫动态属性
        print("person is walking...")

def03.py

面向进度的编制程序:函数式编程。C程序等。依据工作逻辑从上到下写代码

类有三种意义:属性援引和实例化

 6 
 7 def dog(name,gender,type):
 8     def jiao(dog):
 9         print('一条狗[%s],汪汪'%dog['name'])
10 
11     def yaoren(dog):
12         print('一条狗[%s]正在咬人'%dog['type'])
13 
14     dog1 = {
15         'name': name,
16         'gender': gender,
17         'type': type,
18         'jiao':jiao,#内部函数
19         'yaoren':yaoren#内部函数
20     }
21     return dog1#因为作用域的问题,所以一定要用内部的return 返回jiao,yaoren的函数,才能被外部调用
22 
23 d1 = dog('张明','母','腊肠')

24 d1['jiao'](d1)#引入返回的那个数组d1 ,

面向对象的编制程序:C . Java, Python等。对函数举行分拣和打包,让开垦“更加快越来越好更加强

 性能援引(类名.属性卡塔 尔(阿拉伯语:قطر‎

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

面向对象设计,Python面向对象编程。 

类和目的:是面向对象中的多个重视概念

实例化:类名加括号正是实例化,会自行触发__init__函数的运维,能够用它来为各样实例定制本人的特征

pc28.am 1

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;

    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

pc28.am 2

实例化的历程正是类——>对象的长河

原先大家唯有二个Person类,在此个进度中,发生了一个egg对象,有友好具体的名字、攻击力和生命值。

语法:对象名 = 类名(参数)

egg = Person('egon')  #类名()就等于在执行Person.__init__()
#执行完__init__()就会返回一个对象。这个对象类似一个字典,存着属于这个人本身的一些属性和方法。
#你可以偷偷的理解:egg = {'name':'egon','walk':walk}

def04.py

类:是对食物的抽象,举个例子:动物

翻看属性&调用方法

print(egg.name)     #查看属性直接 对象名.属性名
print(egg.walk())   #调用方法,对象名.方法名()
 6 
 7 def dog(name,gender,type):
 8     def jiao(dog):
 9         print('一条狗[%s],汪汪'%dog['name'])
10 
11     def yaoren(dog):
12         print('一条狗[%s]正在咬人'%dog['type'])
13 
14     def init(name,gender,type):
15         dog1 = {
16             'name': name,
17             'gender': gender,
18             'type': type,
19             'jiao':jiao,#内部函数
20             'yaoren':yaoren#内部函数
21         }
22         return dog1
23 
24     return init(name,gender,type)
25 
26 d1 = dog('张明','母','腊肠')

26 print(d1['name'],d1['gender'])

27 d1['jiao'](d1)#引入返回的那个数组d1 ,

目的:是类的二个实例,比方:猫,狗等

关于self

self:在实例化时自动将目的/实例本身传给__init__的第三个参数,也能够起各自的名字,但是常常不会这么做,大家萧规曹随为self,改进之后不便于识别。

# 那么一个函数,
# 正是给定不一样属性,设置属性到它里面,
# 何况它此中的函数使用了那个属性,实现了新的动作,
# 通过再次回到方法至二个字典个中,让外界调用这一个办法(属性和章程都急需让外界去做客,在字典类型当中来说,是少年老成律的卡塔 尔(英语:State of Qatar),
# 即完结了所谓的【面向对象】

举个例子说:动物能够对猫的特征和行事展开抽象,然后可以实例化为意气风发台实在的动物实体出来。

类属性的补给

一:我们定义的类的属性到底存到哪里了?有两种方式查看
dir(类名):查出的是一个名字列表
类名.__dict__:查出的是一个字典,key为属性名,value为属性值

二:特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

# 对象在不描述在此以前什么都不是。
# 对象正是索要描述它的动作和天性,技术去定义它。比方:人,长什么样,能做什么样;灯泡,是怎样,能做怎么样。

#########

对象的相干知识

# 类是虚幻的,唯有属性和情势。 dog()函数就是
# 但对象是经过动作和特点的概念的。d1 定义后,就是一条狗了
# 这就是面向对象设计

此间想放几张图纸的,传不上去就不放了

对象是关于类而实在存在的三个例子,即实例

类就好像模板,定义后就是二个对象了。

猫(对象)         动物(类)       狗(对象)

目的/实例独有后生可畏种作用:属性援引

pc28.am 3pc28.am 4

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):
        # 人可以攻击狗,这里的狗也是一个对象。
        # 人攻击狗,那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivit

# 引用
egg = Person('egon',10,1000)
print(egg.name)
print(egg.aggressivity)
print(egg.life_value)

人狗大战

也能够援引三个办法,因为方法也是多本性质,只可是是三个好像函数的习性,大家也管它叫动态属性。
援用动态属性并非执行那几个艺术,要想调用方法和调用函数是同后生可畏的,都亟待在背后加上括号

print(egg.attack)

自己晓得在类里说,你恐怕还会有非常多地点无法分晓。那大家就用函数来解释一下这些类呀,对象啊到底是个吗,你悄悄的用这些精晓就好了,不要告诉外人

pc28.am 5pc28.am 6

def Person(*args,**kwargs):
    self = {}
    def attack(self,dog):
        dog['life_value'] -= self['aggressivity']

    def __init__(name,aggressivity,life_value):
        self['name'] = name
        self['aggressivity'] = aggressivity
        self['life_value'] = life_value
        self['attack'] = attack

    __init__(*args,**kwargs)
    return self

egg = Person('egon',78,10)
print(egg['name'])

赞助精晓面向对象

面向对象小结——定义及调用的定位格局

pc28.am 7pc28.am 8

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例,代表一个具体的东西
                  #类名() : 类名 括号就是实例化一个类,相当于调用了__init__方法
                  #括号里传参数,参数不需要传self,其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

小结

pc28.am 9pc28.am 10

练习一:在终端输出如下信息

小明,10岁,男,上山去砍柴
小明,10岁,男,开车去东北
小明,10岁,男,最爱大保健
老李,90岁,男,上山去砍柴
老李,90岁,男,开车去东北
老李,90岁,男,最爱大保健
老张…

class who:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def s(self):
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))
        print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.sex))
        print('%s,%s岁,%s,最爱大保健'%(self.name,self.age,self.sex))

ss = who('小明',10,'男')
ss.s()

习题

由 类-----爆发-----对象的进程叫抓实例化(实例=对象卡塔 尔(阿拉伯语:قطر‎

#########

目的之间的相互作用

人狗战役之血腥互搏

pc28.am 11pc28.am 12

class Dog:  # 定义一个狗类
    role = 'dog'  # 狗的角色属性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人,这里的狗也是一个对象。
        # 狗咬人,那么人的生命值就会根据狗的攻击力而下降
     dog.life_value -= self.aggressivit

开创一个类(狗类)

 在python个中,未有供给你势需求写面向对象的代码。用面向对象的言语,和多个顺序的布署性是面临对象的,两个无此外关联。

设计思想:现实世界中,任何贰个操作照旧是业务逻辑的达成都亟需七个实体来变成,也正是说,实体就是动作的支配者,未有实体,就一定没有动作发生!

实例化三只实实在在的狗

ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2

你写的程序是还是不是面向对象的,和您用的言语是否面向对象的毫不相关系!面向对象设计,只但是是函数/进程式编程的变异。关键在于面向对象的宏图思路。

后天让我们寻思下,关于喝水这么些动作有哪些动词?

交互 egon打ha2一下

print(ha2.life_value)         #看看ha2的生命值
egg.attack(ha2)               #egg打了ha2一下
print(ha2.life_value)         #ha2掉了10点血

 

拿杯子、接水、抬手、张嘴

完整的代码

pc28.am 13pc28.am 14

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):
        # 人可以攻击狗,这里的狗也是一个对象。
        # 人攻击狗,那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivity

class Dog:  # 定义一个狗类
    role = 'dog'  # 狗的角色属性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人,这里的狗也是一个对象。
        # 狗咬人,那么人的生命值就会根据狗的攻击力而下降
        people.life_value -= self.aggressivity

egg = Person('egon',10,1000)  #创造了一个实实在在的人egg
ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2
print(ha2.life_value)         #看看ha2的生命值
egg.attack(ha2)               #egg打了ha2一下
print(ha2.life_value)         #ha2掉了10点血

人狗互搏之孰生孰死

pc28.am 15pc28.am 16

#计算圆周长以及圆的面积

from math import pi

class Circle:
    '''
    定义了一个圆形类;
    提供计算面积(area)和周长(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10) #实例化一个圆
area1 = circle.area() #计算圆面积
per1 = circle.perimeter() #计算圆周长
print(area1,per1) #打印圆面积和周长

回顾示例扶助理解面向对象

有动词就一定有落到实处那么些动作的实体!

类命名空间与对象、实例的命名空间

成立叁个类就能创造三个类的名号空间,用来积攒类中定义的具知名字,那个名字称为类的习性

而类有三种属性:静态属性和动态属性

  • 静态属性正是间接在类中定义的变量
  • 动态属性就是概念在类中的方法

所谓的效仿现实世界,正是使计算机的编制程序语言在化解相关工作逻辑的秘诀,与诚恳的作业逻辑的产生保持生龙活虎致!需求使每个动作的幕后都一个到位这么些动作的实业!

在那之中类的数量属性是分享给全部目的的

>>>id(egg.role)
4341594072
>>>id(Person.role)
4341594072

因为任何效能的落到实处都以依附于三个实际的实业的“动作|操作|行动”,能够看成是二个又二个的实体在表明其各自的“技能”并在中间开展协调有序的调用进程!

而类的动态属性是绑定到具备目的的

>>>egg.attack
<bound method Person.attack of <__main__.Person object at 0x101285860>>
>>>Person.attack
<function Person.attack at 0x10127abf8> 

开创一个指标/实例就能够创制八个目的/实例的名称空间,存放对象/实例的名字,称为对象/实例的性质

在obj.name会先从obj自个儿的称谓空间里找name,找不到则去类中找,类也找不到就找父类...最终都找不到就抛出极度

 

当使用面向对象的合计解除难题时,可分为上边几步:

面向对象的咬合用法

软件重用的重要性艺术除了三番三回之外还应该有此外生机勃勃种方法,即:组合

组成指的是,在二个类中以此外一个类的指标作为数据属性,称为类的咬合

pc28.am 17pc28.am 18

class Weapon:
    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称;
        self.weapon = Weapon()  # 给角色绑定一个武器;

egg = Person('egon')
egg.weapon.prick() 
#egg组合了一个武器的对象,可以直接egg.weapon来使用组合类中的所有方法

结合示例

圆环是由八个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是当中圆的周长加上外国国语大学表圆的周长。
此时,大家就率先贯彻一个圆形类,计算叁个圆的周长和面积。然后在"环形类"中结成圆形的实例作为自个儿的习性来用

pc28.am 19pc28.am 20

from math import pi

class Circle:
    '''
    定义了一个圆形类;
    提供计算面积(area)和周长(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10) #实例化一个圆
area1 = circle.area() #计算圆面积
per1 = circle.perimeter() #计算圆周长
print(area1,per1) #打印圆面积和周长

class Ring:
    '''
    定义了一个圆环类
    提供圆环的面积和周长的方法
    '''
    def __init__(self,radius_outside,radius_inside):
        self.outsid_circle = Circle(radius_outside)
        self.inside_circle = Circle(radius_inside)

    def area(self):
        return self.outsid_circle.area() - self.inside_circle.area()

    def perimeter(self):
        return  self.outsid_circle.perimeter()   self.inside_circle.perimeter()


ring = Ring(10,5) #实例化一个环形
print(ring.perimeter()) #计算环形的周长
print(ring.area()) #计算环形的面积

测算圆环的面积和周长

用整合的章程创设了类与整合的类之间的涉嫌,它是风华正茂种‘有’的涉嫌,比方教师有生辰,教授教python课程

pc28.am 21pc28.am 22

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

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

class Teacher:
    def __init__(self,name,gender,birth,course):
        self.name=name 
        self.gender=gender
        self.birth=birth
        self.course=course
    def teach(self): 
        print('teaching')

p1=Teacher('egon','male', 
            BirthDate('1995','1','27'), 
            Couse('python','28000','4 months')
           ) 

print(p1.birth.year,p1.birth.month,p1.birth.day) 

print(p1.course.name,p1.course.price,p1.course.period)
''' 
运行结果: 
1995 1 27 
python 28000 4 months 
'''

View Code

当类之间有显明分裂,况兼超小的类是比较大的类所急需的零器件时,用整合比较好

1深入分析哪些动作是由哪些实体发出的;

初识面向对象小结

pc28.am 23pc28.am 24

#定义一个人的类
class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value, money):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;
        self.money = money

    def attack(self,dog):
        # 人可以攻击狗,这里的狗也是一个对象。
        # 人攻击狗,那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivity
#定义一个狗的类
class Dog:  # 定义一个狗类
    role = 'dog'  # 狗的角色属性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人,这里的狗也是一个对象。
        # 狗咬人,那么人的生命值就会根据狗的攻击力而下降
        people.life_value -= self.aggressivity
#定义一个兵器类
class Weapon:
    def __init__(self,name, price, aggrev, life_value):
        self.name = name
        self.price = price
        self.aggrev = aggrev
        self.life_value = life_value

    def update(self, obj):  #obj就是要带这个装备的人
        obj.money -= self.price  # 用这个武器的人花钱买所以对应的钱要减少
        obj.aggressivity  = self.aggrev  # 带上这个装备可以让人增加攻击
        obj.life_value  = self.life_value  # 带上这个装备可以让人增加生命值

    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500
#测试交互
lance = Weapon('长矛',200,6,100)
egg = Person('egon',10,1000,600)  #创造了一个实实在在的人egg
ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2

#egg独自力战"二愣子"深感吃力,决定穷毕生积蓄买一把武器
if egg.money > lance.price: #如果egg的钱比装备的价格多,可以买一把长矛
    lance.update(egg) #egg花钱买了一个长矛防身,且自身属性得到了提高
    egg.weapon = lance #egg装备上了长矛

print(egg.money,egg.life_value,egg.aggressivity)

print(ha2.life_value)
egg.attack(ha2)   #egg打了ha2一下
print(ha2.life_value)
egg.weapon.prick(ha2) #发动武器技能
print(ha2.life_value) #ha2不敌狡猾的人类用武器取胜,血槽空了一半

打闹小例

依据这种思路一点一点的设计类和对象,最后完全能够兑现三个周密的对阵类游戏。

2定义这几个实体,为其扩大对应的习性和成效;

面向对象的三大特征

3让实体去实行相应的成效或动作。

继承

使用OOP编制程序的显要目标:

什么是后续

后续是后生可畏种创造新类的情势,在python中,新建的类能够三翻五次一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类

 

python中类的持续分为:单继承和多世袭

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

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

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

翻看世襲

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

提示:若无一点名基类,python的类会默许继承object类,object是有所python类的基类,它提供了有的科学普及方法(如__str__)的实现。

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

面向对象是为了消除系统的可维护性,可扩大性,可重用性,大家再进一层思量,面向对象为何能一蹴而就系统的可维护性,可扩张性,可重用性?

大浪涛沙与虚空(先抽象再持续卡塔 尔(阿拉伯语:قطر‎

泛泛即抽出形似只怕说相比较像的部分。

空洞分成五个档案的次序: 

1.将前美利坚合众国总统和Messi这俩对象比较像的黄金时代部分抽出成类; 

2.将人,猪,狗那多少个类比较像的某个抽出成父类。

虚幻最器重的效用是分开体系(能够凝集关注点,裁减复杂度卡塔 尔(英语:State of Qatar)

pc28.am 25

三番五次:是依照抽象的结果,通过编程语言去得以落成它,显明是先经验抽象那几个历程,技能由此延续的方法去表达出抽象的布局。

虚幻只是深入分析和设计的长河中,一个动作也许说黄金年代种本领,通过架空可以获得类

pc28.am 26

面向对象发生的野史由来有下边两点:

接轨与重用性

pc28.am 27pc28.am 28

==========================第一部分
例如

  猫可以:喵喵叫、吃、喝、拉、撒

  狗可以:汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,伪代码如下:


#猫和狗有大量相同的内容
class 猫:

    def 喵喵叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗:

    def 汪汪叫(self):
        print '汪汪叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something



==========================第二部分
上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:

  动物:吃、喝、拉、撒

     猫:喵喵叫(猫继承动物的功能)

     狗:汪汪叫(狗继承动物的功能)

伪代码如下:
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
class 猫(动物):

    def 喵喵叫(self):
        print '喵喵叫'

# 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
class 狗(动物):

    def 汪汪叫(self):
        print '汪汪叫'




==========================第三部分
#继承的代码实现
class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

    def shit(self):
        print ("%s 拉 " %self.name)

    def pee(self):
        print ("%s 撒 " %self.name)


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫')

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'

    def cry(self):
        print('汪汪叫')


# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

使用继承来重用代码比较好的例子

使用继承来解决代码重用的例子

应用持续来减轻代码重用的例证

在开采顺序的经过中,假设大家定义了一个类A,然后又想新成立此外三个类B,但是类B的大部内容与类A的平等时

咱俩十分的小概从头早前写三个类B,这就用到了类的后续的定义。

通过一连的章程新建类B,让B世袭A,B会‘遗传’A的富有属性(数据属性和函数属性),实今世码重用

class Animal:
    '''
    人和狗都是动物,所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有自己的昵称;
        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;
        self.life_value = life_value  # 人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    pass

class Person(Animal):
    pass

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
egg.eat()
ha2.eat()

唤醒:用已经部分类创建三个新的类,那样就收音和录音了曾经有个别软件中的少年老成局地装置大多数,大大生了编制程序专业量,那正是常说的软件重用,不仅可以够重用自个儿的类,也得以继续外人的,举例标准库,来定制新的数据类型,那样正是大大降低了软件开采周期,对大型软件开荒来讲,意义重大.

1、 计算机是支援大家肃清难题的,可是Computer究竟是个机器,他只会根据人所写的代码,一步一步的实践下去,最后收获了结果,由此无论程序多么的繁杂,Computer总是能轻轻易松应付,结构化编制程序,正是坚决守住Computer的沉凝写出的代码,不过人看到如此复杂的逻辑,就十分的小概维护和扩大了。

派生

子类也能够增进本人新的习性只怕在大团结这里再度定义那些属性(不会影响到父类卡塔 尔(阿拉伯语:قطر‎,需求注意的是,生机勃勃旦重新定义了同心同德的品质且与父类重名,那么调用新扩展的性质时,就以投机为准了。

class Animal:
    '''
    人和狗都是动物,所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有自己的昵称;
        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;
        self.life_value = life_value  # 人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    '''
    狗类,继承Animal类
    '''
    def bite(self, people):
        '''
        派生:狗有咬人的技能
        :param people:  
        '''
        people.life_value -= self.aggressivity

class Person(Animal):
    '''
    人类,继承Animal
    '''
    def attack(self, dog):
        '''
        派生:人有攻击的技能
        :param dog: 
        '''
        dog.life_value -= self.aggressivity

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)

注意:像ha2.life_value之类的性质援用,会先从实例中找life_value然后去类中找,然后再去父类中找...直到最一级的父类。

在子类中,新建的重名的函数属性,在编写函数内功用的时候,有比异常的大也许需求引用父类中重名的不得了函数功用,应该是用调用普通函数的方法,即:类名.func(),那个时候就与调用普通函数一点差别也未有了,由此固然是self参数也要为其传值.

在python3中,子类施行父类的措施也足以一贯用super方法.

pc28.am 29pc28.am 30

class A:
    def hahaha(self):
        print('A')

class B(A):
    def hahaha(self):
        super().hahaha()
        #super(B,self).hahaha()
        #A.hahaha(self)
        print('B')

a = A()
b = B()
b.hahaha()
super(B,b).hahaha()

pc28.am,帮您精通super

class Animal:
    '''
    人和狗都是动物,所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有自己的昵称;
        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;
        self.life_value = life_value  # 人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    '''
    狗类,继承Animal类
    '''
    def __init__(self,name,breed,aggressivity,life_value):
        super().__init__(name, aggressivity, life_value) #执行父类Animal的init方法
        self.breed = breed  #派生出了新的属性

    def bite(self, people):
        '''
        派生出了新的技能:狗有咬人的技能
        :param people:  
        '''
        people.life_value -= self.aggressivity

    def eat(self):
        # Animal.eat(self)
        #super().eat()
        print('from Dog')

class Person(Animal):
    '''
    人类,继承Animal
    '''
    def __init__(self,name,aggressivity, life_value,money):
        #Animal.__init__(self, name, aggressivity, life_value)
        #super(Person, self).__init__(name, aggressivity, life_value)
        super().__init__(name,aggressivity, life_value)  #执行父类的init方法
        self.money = money   #派生出了新的属性

    def attack(self, dog):
        '''
        派生出了新的技能:人有攻击的技能
        :param dog: 
        '''
        dog.life_value -= self.aggressivity

    def eat(self):
        #super().eat()
        Animal.eat(self)
        print('from Person')

egg = Person('egon',10,1000,600)
ha2 = Dog('二愣子','哈士奇',10,1000)
print(egg.name)
print(ha2.name)
egg.eat()

通过持续创建了派生类与基类之间的关联,它是生龙活虎种'是'的关系,举例白马是马,人是动物。

当类之间有繁多平等的功力,提取那一个合营的效劳做成基类,用三番五次比较好,譬喻教师是教授

>>> class Teacher:
...     def __init__(self,name,gender):
...         self.name=name
...         self.gender=gender
...     def teach(self):
...         print('teaching')
... 
>>> 
>>> class Professor(Teacher):
...     pass
... 
>>> p1=Professor('egon','male')
>>> p1.teach()
teaching

2、 构造化设计是以功效为对象来设计结构采纳类别,这种做法导致大家安插程序时,必须要将合理所结合的实际世界映射到由效率模块组成的解空间中,这种转移进程,背离了人人观察和缓慢解决难题的基本思路。

抽象类与接口类

看得出构造化设计在兼顾系统的时候,不可能消除重用、维护、扩展的标题,何况会促成逻辑过于复杂,代码晦涩难懂。于是大家就想,能还是无法让Computer直接模拟现实的境遇,用人类化解难点的思绪,习惯,步骤来两全相应的应用程序?那样的程序,大家在读它的时候,会更便于理解,也无需再把现实世界和程序世界之间往来做调换。

接口类

三回九转有两用:

风华正茂:世袭基类的法子,何况做出自个儿的转移照旧扩充(代码重用卡塔 尔(阿拉伯语:قطر‎  

二:注脚有个别子类宽容于某基类,定义一个接口类Interface,接口类中定义了有些接口名(正是函数名卡塔尔且未有实现接口的职能,子类世继承口类,并且完毕接口中的成效

class Alipay:
    '''
    支付宝支付
    '''
    def pay(self,money):
        print('支付宝支付了%s元'%money)

class Applepay:
    '''
    apple pay支付
    '''
    def pay(self,money):
        print('apple pay支付了%s元'%money)


def pay(payment,money):
    '''
    支付函数,总体负责支付
    对应支付的对象和要支付的金额
    '''
    payment.pay(money)


p = Alipay()
pay(p,200)

支付中易于并发的标题

class Alipay:
    '''
    支付宝支付
    '''
    def pay(self,money):
        print('支付宝支付了%s元'%money)

class Applepay:
    '''
    apple pay支付
    '''
    def pay(self,money):
        print('apple pay支付了%s元'%money)

class Wechatpay:
    def fuqian(self,money):
        '''
        实现了pay的功能,但是名字不一样
        '''
        print('微信支付了%s元'%money)

def pay(payment,money):
    '''
    支付函数,总体负责支付
    对应支付的对象和要支付的金额
    '''
    payment.pay(money)


p = Wechatpay()
pay(p,200)   #执行会报错

接口初成:手动报那二个:NotImplementedError来解决开采中相遇的标题

class Payment:
    def pay(self):
        raise NotImplementedError

class Wechatpay(Payment):
    def fuqian(self,money):
        print('微信支付了%s元'%money)


p = Wechatpay()  #这里不报错
pay(p,200)      #这里报错了

借用abc模块来得以实现接口

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):
        pass


class Wechatpay(Payment):
    def fuqian(self,money):
        print('微信支付了%s元'%money)

p = Wechatpay() #不调就报错了

推行中,世袭的率先种意义意义并不极大,以至有的时候是危机的。因为它使得子类与基类出现强耦合。

接轨的第三种意义特别重要。它又叫“接口世袭”。
接口世襲实质上是讲求“做出三个杰出的充饥画饼,这几个抽象规定了二个天造地设接口,使得外界调用者无需关心具体细节,可并列排在一条线的拍卖完成了一定接口的保有目的”——那在前后相继设计上,叫做归黄金时代化。

归意气风发化使得高层的表面使用者能够不加区分的拍卖全体接口宽容的目的集结——就好象linux的泛文件概念相似,全数东西都足以当文件处理,不必关怀它是内存、磁盘、互联网只怕荧屏(当然,对底层设计者,当然也得以区分出“字符设备”和“块设备”,然后做出针对性的规划:细致到哪边水平,视须要而定卡塔 尔(英语:State of Qatar)。

#依赖倒置原则:
#高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该应该依赖细节;细节应该#依赖抽象。换言之,要针对接口编程,而不是针对实现编程

在python中向来就一直不四个称呼interface的主要字,下面包车型大巴代码只是看起来像接口,其实并未有起到接口的效果,子类完全可以不用去完毕接口 ,如若非要去模仿接口的定义,能够依附第三方模块:

twisted的twistedinternetinterface.py里使用zope.interface

文档

设计方式:

pc28.am 31pc28.am 32

#接口提取了一群类共同的函数,可以把接口当做一个函数的集合。

#然后让子类去实现接口中的函数。

#这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。

#归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。

#比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。

#再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样

为什么要用接口

再正是,大家开掘,在具体世界中留存的客观是难点域中的主演,所谓客体是指客观存在的靶子实体和不合理抽象的定义,这种合理具备属性和行为,而客观是稳固的,行为不稳固的,同期合理之间有着各类关系,因而面向客体编制程序,比面向行为编制程序,系统会更安定,在面对再三的供给变动时,退换的高频是表现,而客观平常没有必要更换,所以大家就把作为封装起来,那样更改时候只需求更改行为就能够,主结构则保持了安宁。

抽象类

何以是抽象类

*    与java同样,python也可以有抽象类的概念不过雷同必要依据模块完结,抽象类是贰个例外的类,它的例外之处在于只好被接续,无法被实例化*

为啥要有抽象类

    如果说类是从一堆对象中抽出雷同的内容而来的,那么抽象类是从一堆中收取形似的内容而来的,内容富含数据属性和函数属性。

*  举个例子咱们有美蕉的类,有苹果的类,有黄桃的类,从那些类抽出相符的剧情正是水果这么些抽象的类,你吃水果时,要么是吃一个具体的金蕉,要么是吃叁个活灵活现的黄桃。。。。。。你永久不可能吃到多个名叫水果的东西。*

*    从设计角度去看,借使类是从现实对象抽象而来的,那么抽象类正是基于类硕华而不实而来的。*

*  从贯彻角度来看,抽象类与普通类的分裂之处在于:抽象类中有抽象方法,该类不可能被实例化,只可以被接续,且子类必须实现抽象方法。这或多或少与接口有一些形似,但其实是例外的,将要宣布答案*

在python中落到实处抽象类

pc28.am 33pc28.am 34

#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法,无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法,无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

View Code

于是乎面向对象就时有产生了。

抽象类与接口类

抽象类的真相依旧类,指的是风度翩翩组类的相通性,富含数据属性(如all_type卡塔尔国和函数属性(如read、write卡塔尔,而接口只重申函数属性的相似性。

抽象类是八个在于类和接口直接的一个概念,相同的时候拥有类和接口的局地天性,能够用来促成归风流倜傥化设计 

在python中,并从未接口类这种事物,固然不经过特意的模块定义接口,我们也应有有部分中坚的定义。

只是人们追求的系统可维护性,可扩大性,可重用性又是怎么在面向对象中反映出来的啊?

1.多三翻五次难点

在三番五次抽象类的进程中,我们应当尽量制止多三番五次;
而在持续接口的时候,我们反而慰勉你来多三翻五次接口

接口隔离原则:
使用多个专门的接口,而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。

先是拜见面向对象的三大特点:

2.方法的落到实处

在抽象类中,大家可以对有的空洞方法做出底子达成;
而在接口类中,任何方法都只是生机勃勃种规范,具体的意义供给子类达成

打包:找到变化并且把它包裹起来,你就足以在不影响其余一些的事态下修改或扩张被包裹的成形部分,那是负有设计格局的根底,正是包裹变化,因此封装的功用,就缓和了前后相继的可扩张性。

钻石继承

三回九转:子类世襲父类,可以世袭父类的措施及质量,实现了多态以致代码的选定,因而也消除了系统的重用性和扩张性,不过后续破坏了打包,因为他是对子类开放的,校订父类会促成全部子类的改革,因而继承一定水平上又破坏了系统的可扩充性,所以接二连三供给慎用,独有明确的IS-A关系本领运用,同期继续在在程序支付进度中重构获得的,实际不是前后相继设计之初就应用持续,很多面向对象开垦者滥用世袭,结酚酞致前期的代码清除不了供给的生成了。由此预先使用组合,实际不是持续,是面向对象开辟中贰个第生龙活虎的经历。

波澜起伏顺序

pc28.am 35

 

pc28.am 36pc28.am 37

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表,经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

继承顺序

后续顺序

多态:接口的多样不相同的兑现格局即为多态。接口是对作为的虚幻,刚才在包装提到,找到变化部分并打包起来,不过封装起来后,怎么适招待下去的改动?那多亏接口的功效,接口的要紧目标是为不相干的类提供通用的拍卖服务,大家得以伪造一下。举个例子鸟会飞,可是超人也会飞,通过飞这么些接口,大家得以让鸟和独立,都落到实处那么些接口,那就落到实处了系统的可维护性,可扩充性。

一而再一而再原理

python到底是如何落到实处持续的,对于你定义的每叁个类,python会总括出二个主意分析顺序(MRO)列表,那一个MRO列表就是三个粗略的有着基类的线性顺体系表,例如

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了完成三番两次,python会在MRO列表上从左到右开端查找基类,直到找到第八个门道相当那几个特性的类截止。
而这些MRO列表的构造是经过三个C3线性化算法来贯彻的。我们不去商讨那些算法的数学原理,它实质上正是联合全部父类的MRO列表并信守如下三条法则:
1.子类会先于父类被检查
2.多少个父类会依据它们在列表中的顺序被检查
3.即使对下叁个类存在八个官方的选料,选拔第三个父类

之所以面向对象能兑现大家追求的系统可维护性,可扩大性,可重用性。面向对象是黄金时代种编制程序观念,初步,“面向对象”是专指在程序设计中运用封装、世襲、多态等规划方法,但面向对象的观念已经涉嫌到软件开荒的种种方面,比方以后分开为了面向对象的剖析(OOA),面向对象的宏图(OOD),面向对象的编制程序完结(OOP)

大浪涛沙小结

2类

后续的法力

减少代码的重用
提高代码可读性
规范编程模式

2.1类的注脚和开创

多少个名词

抽象:抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
继承:子类继承了父类的方法和属性
派生:子类在父类方法和属性的基础上产生了新的方法和属性

Python 类使用class关键字来创制。轻松的类评释能够是关键字后紧跟类名。类注明与函数证明很相近,头后生可畏行用二个应和的第一字,接下去是一个当作它的定义代码体,如下所示:

抽象类与接口类

pc28.am 38

1.多继承问题
在继承抽象类的过程中,我们应该尽量避免多继承;
而在继承接口的时候,我们反而鼓励你来多继承接口


2.方法的实现
在抽象类中,我们可以对一些抽象方法做出基础实现;
而在接口类中,任何方法都只是一种规范,具体的功能需要子类实现

pc28.am 39

     

钻石世襲

新式类:广度优先
经典类:深度优先

ClassClassName (bases)

多态

      Class documentation string  #类文书档案字符串

多态

多态指的是意气风发类东西有多样形象

动物有种种模样:人,狗,猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

文件有三种形态:文本文件,可施行文件

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

      class_suite #类体

多态性

风流浪漫 什么是多态动态绑定(在继续的背景下使用时,不常也称为多态性卡塔尔

多态性是指在不思索实例类型的事态下利用实例

#在面向对象方法中一般是这样表述多态性:
#向不同的对象发送同一条消息(!!!obj.func():是调用了obj的方法func,又称为向obj发送了一条消息func),不同的对象在接收时会产生不同的行为(即方法)。
#也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

#比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,虽然二者消息一样,但是执行的效果不同

多态性

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

硬尾鸭类型

逗比整天:

  Python崇尚树鸭类型,即‘假设看起来像、叫声音图像并且走起路来像红鸭,那么它正是硬尾鸭’

python工程师平常遵照这种作为来编写程序。举例,如若想编写现成对象的自定义版本,能够三番四回该对象

也可以创造多个外观和行事像,但与它无此外关联的全新对象,前面一个平日用于保存程序组件的松耦合度。

例1:利用标准库中定义的各类‘与公事近似’的靶子,固然那个目的的干活方式像文件,但他俩尚无继续内置文件对象的诀要

例2:体系类型有八种造型:字符串,列表,元组,但她俩直白未有直接的接续关系

pc28.am 40pc28.am 41

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

例子

1行使紧要字Class定义三个类,况兼类名的首字母要大写;

封装

【封装】

         隐蔽对象的属性和落到实处细节,仅对外提供公共访谈情势。

【好处】 

  1. 将扭转隔开分离; 

  2. 平价使用;

  3. 加强复用性; 

  4. 加强安全性;

【封装原则】

      1. 将无需对外提供的源委都逃避起来;

      2. 把质量都藏匿,提供公共措施对其访谈。

2当程序猿须要创设的类型无法用轻松类型表示时就供给成立类;

村办变量和村办方法

在python中用双下划线在此以前的方法将质量隐蔽起来(设置成私有的卡塔尔

3类把须求的变量和函数组合在一起,这种带有也称之为“封装”。

个体变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__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是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形

这种活动变形的本性:

1.类中定义的__x只好在内部采取,如self.__x,**援用的正是变形的结果**。

2.这种变形其实就是针对外界的变形,在外界是回天无力透过__x这么些名字采访到的。

3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变造成了:_子类名__x,而父类中变产生了:_父类名__x,即双下滑线开首的质量在继续给子类时,子类是不可能覆盖的。**

 

这种变形供给注意的主题素材是:

1.这种机制也并未真正意义上约束大家从表面直接访问属性,知道了类名和质量名就可以拼盛名字:_类名__品质,然后就足以访谈了,如a._A__N

2.变形的进度只在类的此中生效,在概念后的赋值操作,不会变形

pc28.am 42

Class 类名:

民用方法

3.在继续中,父类假诺不想让子类覆盖本身的办法,能够将艺术定义为私有的

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B


#把fa定义成私有的,即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A

       成员变量

包装与扩张性

封装在于显然区分内外,使得类完结者能够改进封装内的事物而不影响外界调用者的代码;而外界使用用者只略知豆蔻梢头二二个接口(函数),只要接口(函数卡塔 尔(阿拉伯语:قطر‎名、参数不改变,使用者的代码永久不须求更动。那就提供多个美好的搭档底子——或然说,只要接口那一个根基约定不改变,则代码改变不值一提。

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口,隐藏了内部的实现细节,此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者,轻松的扩展了功能,而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口,隐藏内部实现,此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法,但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说,根本无需改动自己的代码,就可以用上新功能
>>> r1.tell_area()

分子函数

property属性

怎么是特色property

property是后生可畏种特殊的本性,访谈它时会实施生龙活虎段功效(函数卡塔尔然后重临值

#例一:BMI指数(bmi是计算而来的,但很明显它听起来像是一个属性而非方法,如果我们将其做成一个属性,更便于理解)

#成人的BMI数值:
#过轻:低于18.5
#正常:18.5-23.9
#过重:24-27
#肥胖:28-32
#非常肥胖, 高于32
#  体质指数(BMI)=体重(kg)÷身高^2(m)
#  EX:70kg÷(1.75×1.75)=22.86

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**2)

p1=People('egon',75,1.85)
print(p1.bmi)

pc28.am 43pc28.am 44

import math
class Circle:
    def __init__(self,radius): #圆的半径radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #计算面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''


#注意:此时的特性area和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

例二:圆的周长和面积

干什么要用property

将八个类的函数定义成特色现在,对象再去选拔的时候obj.name,根本不能够察觉本身的name是奉行了叁个函数然后计算出来的,这种特点的使用方式遵照了联合访问的法规

除了,看下

#ps:面向对象的封装有三种方式:
【public】
#这种其实就是不封装,是对外公开的
【protected】
#这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
#这种封装对谁都不公开

python并不曾经在语法上把它们八个内建到协和的class机制中,在C 里通常会将具有的具有的数据都设置为私有的,然后提供set和get方法(接口卡塔尔国去设置和获得,在python中经过property方法可以兑现

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

多少个静态属性property本质就是兑现了get,set,delete两种艺术

pc28.am 45pc28.am 46

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

View Code

pc28.am 47pc28.am 48

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

View Code

怎么用?

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

对于Python来讲,申明与定义类没什么分歧,因为她俩是还要扩充的,定义(类体卡塔 尔(阿拉伯语:قطر‎紧跟在宣称(含class关键字的投行【header line】卡塔 尔(英语:State of Qatar)和可选的文书档案字符串前边。同期,全体的形式必得同有时间被定义。

classmethod

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()

例1:

staticmethod

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

ClassRen:

面向对象的愈来愈多表达

      name = “人

面向对象的软件开辟

不知凡多少人在学完了python的class机制之后,蒙受二个生育中的难点,还是会懵逼,那实在太健康了,因为此外程序的付出都以先规划后编制程序,python的class机制只但是是豆蔻梢头种编制程序形式,假设您硬要拿着class去和你的标题死磕,变得更加的懵逼都是分秒钟的事,在那前,软件的花销相对轻巧,从任务的剖判到编写程序,再到程序的调度,能够由一位或多少个小组去达成。但是随着软件规模的神速增大,软件任性面前蒙受的主题材料十二分复杂,必要思谋的要素太多,在一个软件中所发生的荒诞和隐蔽的荒唐、未知的大错特错恐怕达到惊人的水准,这亦非在设计阶段就全盘缓慢解决的。

    所以软件的花费其实一条龙正经,大家所学的只是里面包车型地铁一小部分,三个总体的开支进程,要求明显每种阶段的职务,在保管四个等第正确的前提下再开展下三个阶段的行事,称之为软件工程

    面向对象的软件工程包蕴上边多少个部:

1.面向对象深入分析(object oriented analysis ,OOA卡塔尔

    软件工程中的系统一分配析阶段,须要剖析员和客商结成在一起,对客商的要求做出确切的剖析和明显的抒发,从大的方面分析软件系统应该做什么样,并非怎么去做。面向对象的深入分析要遵守面向对象的定义和措施,在对职责的剖析中,从客观存在的事物和东西之间的关系,贵南出关于的靶子(对象的‘特征’和‘本领’卡塔尔国以至对象时期的联系,并将持有相像属性和作为的目的用贰个类class来标记。

    创设一个能反映那是干活情状的须要模型,那时的模型是总结的。

2 面向对象设计(object oriented design,OOD卡塔尔

    依照面向对象剖判阶段产生的必要模型,对每大器晚成有的各自实行具体的规划。

    首先是类的布置性,类的安顿性只怕满含多少个档次(利用三番若干次与派生机制卡塔尔国。然后以那一个类为功底建议程序设计的笔触和格局,富含对算法的统筹。

    在设计阶段并不牵扯任何一门具体的Computer语言,而是用豆蔻梢头种更通用的叙说工具(如伪代码或流程图卡塔 尔(阿拉伯语:قطر‎来汇报

3 面向对象编制程序(object oriented programming,OOP卡塔 尔(阿拉伯语:قطر‎

    遵照面向对象设计的结果,采用意气风发种Computer语言把它写成程序,能够是python

4 面向对象测验(object oriented test,OOT卡塔 尔(阿拉伯语:قطر‎

    在写好程序后提交客户使用前,必得对前后相继开展严厉的测量检验,测验的目标是开采前后相继中的错误并改良它。

    面向对的测验是用面向对象的法子开展测量试验,以类作为测验的宗旨单元。

5 面向对象维护(object oriendted soft maintenance,OOSM卡塔尔

    正如对别的成品都急需开展览出卖后服务和维护同样,软件在选拔时也会并发部分主题素材,恐怕软件商想改正软件的属性,那就需求修正程序。

    由于应用了面向对象的秘籍开辟顺序,使用程序的爱惜相比比较简单于。

    因为对象的封装性,校勘五个对象对别的的靶子影响比很小,利用面向对象的方法维护程序,大大升高了软件维护的频率,可增加性高。

 

    在面向对象方法中,最先发展的终将是面向对象编制程序(OOP),那时OOA和OOD都还没提欢快起,因而前后相继设计者为了写出面向对象的顺序,还必需深远到深入分析和设计领域,尤其是布署领域,那时候的OOP实际上蕴含了当今的OOD和OOP五个等第,那对前后相继设计者供给相比高,许多个人以为很难调控。

    以后规划多个大的软件,是严俊依照面向对象软件工程的5个级次张开的,那一个5个阶段的干活不是由一位自始至终完结的,而是由区别的人分别成功,那样OOP阶段的天职就比较轻松了。程序编写者只供给基于OOd建议的思路,用面向对象语言编写出程序既可。

    在多少个大型软件开拓进程中,OOP只是比十分小的贰个有的。

    对于全栈开垦的你的话,那三个阶段都有了,对于简易的主题素材,不必严苛服从那一个5个级次实行,往往由程序设计者根据面向对象的不二秘诀开展程序设计,富含类的规划和次序的规划

 

      high = “cm”

多少个概念的求证

 

1.面向对象的次第设计看起来高大上,所以本身在编制程序时就活该有限支撑通篇class,那样写出的顺序一定是好的前后相继(面向对象只适合那个可增添性必要相比较高的气象卡塔 尔(阿拉伯语:قطر‎

2.居四个人心爱得舍不得放手说面向对象三大特征(那是从哪传出来的,封装,多态,世襲?漏洞太多太多,好吧权且称为三大特色卡塔 尔(英语:State of Qatar),那么自个儿在依照面向对象编制程序时,笔者自然要让作者定义的类中总体的蕴藏那三种性情,那样写一定是好的主次

好东西,笔者说六合刀法有十一掌,那么您每趟跟人干仗都要从第少年老成掌打到第18掌这才显得你会了是么:直面仇敌,你打到第三掌对方就早就倒下了,你说,不行,你给老子起来,老子还尚未show完...

3.类有类性质,实例有实例属性,所以大家在定义class时明确要定义出那么多少个类属性,想不到咋办,那就全力以赴的想,定义的越来越多越牛逼

那就犯了四个严重的不当,程序越早面向对象,死的越早,为何面向对象,因为我们要将数据与效果整合到联合,程序全部的布局都尚未出来,或许说要求思忖的标题你都并未有搞明白个八九不离十,你就开头面向对象了,那就招致了,你在那边干想,自感觉想通了,定义了一批属性,结果后来又都用不到,或许想不通到底应该定义啥,那就直接想呢,想着想着就疯了。

您见过哪家商铺要支付一个软件,上来就起来写,分明是频仍的开会切磋布置,请看第八节。

      wight = “kg”

面向对象常用术语

抽象/实现

空洞指对切实世界难题和实业的庐山面目目表现,行为和特色建立模型,营造多个相关的子集,能够用于 绘程序构造,进而完成这种模型。抽象不止囊括这种模型的数目属性,还定义了那些多少的接口。

对某种抽象的落到实处正是对此数额及与之有关接口的现实化(realization)。现实化这些历程对于顾客程序应当是晶莹剔透并且非亲非故的。 

封装/接口

卷入描述了对数码/音信进行掩瞒的历史观,它对数据属性提供接口和寻访函数。通过其余顾客端直接对数据的拜见,无视接口,与封装性皆以反其道而行之的,除非程序猿允许这几个操作。作为达成的 生机勃勃部分,客商端根本就无需驾驭在包装之后,数据属性是什么样组织的。在Python中,全数的类属性都以公开的,但名字恐怕被“混淆”了,以阻挡未经授权的拜谒,但如此而已,再未有其他防守措施了。那就必要在统筹时,对数码提供对应的接口,防止客商程序通过不专门的工作的操作来存取封装的数目属性。

注意:封装绝不是相等“把不想让外人见到、以往恐怕改正的事物用private掩瞒起来”

真的的卷入是,经过深刻的构思,做出能够的空洞,给出“完整且最小”的接口,并使得内部细节能够对外透明

(注意:对外透明的意趣是外界调用者能够安枕无忧的拿走和谐想要的别的作用,全盘意识不到里面细节的留存卡塔 尔(英语:State of Qatar)

合成

合成扩张了对类的 述,使得三个例外的类合成为叁个大的类,来消弭实际主题素材。合成 述了 三个不胜复杂的种类,比如多个类由此外类组成,更加小的机件也只怕是任何的类,数据属性及作为, 全数那些合在一齐,相互是“有二个”的关系。

派生/世袭/世袭构造

派生描述了子类衍生出新的性格,新类保留已存类类型中装有需求的数额和表现,但允许改良可能其余的自定义操作,都不会修改原类的定义。
连绵起伏描述了子类属性从祖先类世袭那样后生可畏种办法
继续构造意味着多“代”派生,能够述成二个“族谱”,三番五次的子类,与祖先类都有关联。

泛化/特化

依照世襲
泛化表示具备子类与其父类及祖先类有平等的性状。
特化描述全部子类的自定义,也等于,什么性质让它与其祖先类差别。

多态与多态性

多态指的是相近种东西的有余情景:水这种东西有二种分歧的场馆:冰,水蒸气

多态性的概念提出了目的如何通过他们协同的习性和动作来操作及拜见,而不需思索他们实际的类。

冰,水蒸气,都连任于水,它们都有四个同名的方式正是形成云,可是冰.变云(),与水蒸气.变云()是一心分歧的长河,即便调用的法子都风姿洒脱致

自省/反射

自省也称作反射,那几个性子显示了某目的是哪些在运转期得到本身消息的。假诺传一个目的给您,你能够获悉它有啥样本领,那是风度翩翩项强盛的表征。假如Python不扶持某种情势的自问功效,dir和type内建函数,将很难符合规律职业。还应该有那么些特殊性质,像__dict__,__name__及__doc__

      def play(self)

           print “LOL”

A= Ren ()

A.name= “浪辉”

A.high= :170cm”

A.weight= “100kg”

A.home= “新乡”

 

 

类的章程中最稀少三个参数self

定叁个类:

Class Ren:

      name = “人

      high = “cm”

      wight = “kg”

      def play(self)

           print “LOL”

name,high,weight为成员变量。Play为成员函数(方法卡塔尔。

2.2目的的创建:

       创造对象的经过称之为实例化;当三个目的被创立后,包蕴多少个方面包车型大巴特色:对象的句柄、属性和章程。

       句柄用于区分不相同的对象

对象的性质和章程与类中的成员变量和分子函数对应

例:平常我们开发一个文件

Input= file (LOL, ‘r’)

这几个进度既是多少个实例化进度,file正是叁个类,只可是是系统定义的,不是大家团结定义的

A= Ren ()

 

即实例化贰个对象,A就有品质和章程即name等等,大家也可对质量进行双重赋值即:

A.name= “浪辉”

A.high= :170cm”

A.weight= “100kg”

各类对象又有两样的脾性,类中平素不常,可在对象中增多属性即

A.home= “新乡”

[if !supportLineBreakNewLine]

[endif]

if __name__ == ‘__main__’: 当这段程序直接实例化这一个指标时能够进行,当被当做一模块模块被其余程序调用时力不从心被实施,那一点在概念函数部分介绍有。

 

2.3 Python对象的种类构造

 

优异对象:当中由属性和艺术结合,属性能够是数据类型也足以是函数类型,如属性为函数则该属性就是两个方法。

       类的个中方法-Python类个中提供了一些之中方法,方法名由上下多少个下划线加字母组成。比如Python的布局函数__init__

摩登对象:概念新型对象,必需世袭object方法,class_name(object) 新型对象提供了对类情势和静态方法的支撑。

2.3类的习性

例2:

Class Digits ():

      A=10

S = Digits ()

B = Digits ()

#先是种状态

Print S.A, B.A Digits.A

#第二种情况

S.A =2

Print S.A, B.A Digits.A

#其二种情状

Print S.A, B.A Digits.A

#结果

情况1的结果是:10 10 10;情状2的结果是:12 10 10;意况3的结果是:12 13 13;

率先为何会有这些标题吧?因为aaa属性被称呼类属性,既然是类属性,那么根据从C /Java这种静态语言使用的资历来决断,类性情应该是为实际例所共享的。很当然的,既然是分享关系,那么从类的层系改变aaa的值,自然其实例的aaa的值也要接着变化了。可是处境3的境况却证实,下面的传教是错的。错何地吧?

Python归于动态强类型的言语,在不菲地点和静态语言不相同,因而,无法把静态语言的平整套到动态语言上来。此中,类性质正是三个很好的例证。

对此属性,我们经常见到使用类.属性或实例.属性的款式调用。

对此属性的安装大家平常接收类.属性= 值或实例.属性= 值的花样

上例中S.aaa = 2等价于S.aaa = S.aaa 2,那句话富含了品质获取及质量设置四个操作

即Python中属性的得到和装置的机制与静态语言是例外的,就是背后机制的不等,招致了Python中类属性不必然是为实在例所分享的,即Python属性坚守两个准绳:

  1. Python中属性的获得是比照从下到上的各类来探究属性;

  2. Python

中的类和实例是三个精光独立的对象;

  1. Python

中的属性设置是指向对象自己进行的;

      此外,类由属性和办法结合,类的性质是对数码的卷入,类的点子则是对类的表现的包裹。类的性情按使用节制分为共有属性和民用属性,类的属性范围决定于属性的名称

      共有属性:全体共有属性就是类二月类外调用的属性

      私有属性:不能够被类以外的函数调用(能够透过instance._classname__attribute情势访谈,但只用于调节和测验程序。定义方式以“__”双下划线开端的积极分子变量就是个体属性,不然是公有属性卡塔 尔(英语:State of Qatar)

      内置属性:由系统在定义类的时候默许增添的,由上下五个下划线组成__doc__等等

例2:

ClassRen:

      name = “人

      high = “cm”

      wight = “kg”

      __money = “doller”

      def play(self)  #self名字随便设定

           print “LOL”

print self.__money

print self.name

A= Ren ()

A.name= “浪辉”

A.high= :170cm”

A.weight= “100kg”

A.home= “新乡”

Ren.high

High,weight,name为国有属性,__money为私有总体性,只好在类内部通过中间方法应用。那样完结对数据的隐形,便于封装。

另外,可通过A.__Ren__money的秘籍访谈私有属性,可是通常不提议选择,平日在测量检验的时候用。

有些出奇性质即停放属性:

C.__name__:类C的名字(字符串)

C.__doc__:类C的文书档案字符串

C.__bases__:类C的装有父类构成的元组

C.__dict__:类C的属性

2.3类的秘籍

例3:

ClassRen:

      name = “人

      high = “cm”

      wight = “kg”

      __money = “doller”

     

def play(self) #self名字随意设定

           print “LOL”

print self.__money

print self.name

print self.__say()

def __say(self):

      print“I love xxx”

     

def School (self)

      print“湖大皇子”

b = classmethod(School)

 

def Student()

      print“大鹏”

c = staticmethod(Student)

 

A= Ren ()

A.name= “浪辉”

A.high= “170cm”

A.weight= “100kg”

A.home= “新乡”

Ren.high

国有方法:类的办法共有方法不能够被类直接调用,需求实例化对象去调用

民用方法:不能够被外表的类和措施调用,私有方法的定义和个体属性的概念都是风流倜傥致的,在艺术的前面加上”__“双下划线就足以了;

类方法:被classmethod()函数处理过的函数,能被类所调用,也能被对象所调用(是三番三回的关系卡塔尔国;

静态方法:卓殊与”全局函数“,能够被类直接调用,能够被抱有实例化对象分享,通过staticmethod()定义静态方法,没有必要”self“语句

上例中的def play(self)为国有方法,可在类中被调用或被实例化调用,可是不能够被类直接调用。def __say(self) 为民用方法,只可以在类中被调用。def School (self)是类情势,可被类直接调用,也可被对象调用。def Student()为静态方法,用法同类形式风姿浪漫致。

类方式和静态方法使用上是风姿罗曼蒂克律的,可是原理上是有分其他。

1静态方法无需加self

2静态方法是调用时会预先将类中用到属性和情势开展加载,而类措施则是随调随用。因而类方法比较静态方法不占能源,不过速度未有静态方法。

3静态方法调用类中的属性时索要   类名.属性

 

      此外,Python有二个装饰器作用,即在三个措施前增进”@classmethod“或”@staticmethod“可高效将此措施设置为类格局或静态方法。

参谋资料:

Python核心编制程序

https://www.cnblogs.com/seesea125/archive/2012/04/03/2431176.html

https://www.cnblogs.com/zln1021/p/6070591.html

https://blog.csdn.net/jianyuerensheng/article/details/51602015

本文由pc28.am发布于计算机编程,转载请注明出处:面向对象设计,Python面向对象编程

上一篇:Python逻辑运算符 下一篇:没有了
猜你喜欢
热门排行
精彩图文
  • 九彩拼盘的前端技能,LayUI框架的应用
    九彩拼盘的前端技能,LayUI框架的应用
    内容: HTML 普及标签和总体性 文书档案类型申明 转义字符 网页访问无障碍(只是掌握卡塔 尔(阿拉伯语:قطر‎ CSS 常用采取器 体制生效准绳(浏览器的
  • 编制程序总计,动态目的
    编制程序总计,动态目的
    dynamic是FrameWork4.0的新特色。dynamic的现身让C#具备了弱语言类型的风味。编写翻译器在编写翻译的时候不再对项目举行检查,编译期暗中同意dynamic对象扶植
  • 动态编写翻译,在线运转
    动态编写翻译,在线运转
    千帆竞发产生c#代码的在线编辑。     在帮顾客写JAVA客商端访谈.NET达成的Webservice的示范代码发掘了一个有意思的标题。为有保持安全性,使用了wse2.0sp
  • 二叉树中度为2的结点
    二叉树中度为2的结点
    int Degree2(BitNode *t){ if(t==null) return 0;if(t-lchild!=nullt-rchild!=null) return 1 Degree2(t-lchild) Degree2(t-rchild);return Degree2(t-lchild) Degree2(t-rchild); } 您可能感兴趣的 非递归先
  • 包的区别
    包的区别
    大家平常在python的模块目录中会看见" __init__.py " 那个文件,那么它终归有啥样功效吗? 类 类的概念在不胜枚举语言中出现,相当轻便驾驭。它将数据和操