通过多少个函数式编号演进,明白面向对象设计

python函数的面向对象——面向对象设计,python面向对象设计

经过几个函数式编号演进,掌握面向对象设计

def01.py

 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)

 def02.py

 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)

def03.py

 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 ,

 

def04.py

 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 ,

# 那么一个函数,
# 便是给定差别性质,设置属性到它里面,
# 并且它里面包车型大巴函数使用了那几个属性,达成了新的动作,
#
通过重回方法至二个字典其中,让外部调用那些办法(属性和措施都亟待让外部去做客,在字典类型个中来讲,是1律的),
# 即完成了所谓的【面向对象】

# 对象在不描述在此之前什么都不是。
#
对象就是亟需描述它的动作和特点,本事去定义它。比方:人,长什么,能做什么样;灯泡,是如何,能做什么样。

#面向对象之壹,面向对象设计。 类是架空的,只有属性和方法。 dog()函数便是
# 但对象是透过动作和个性的定义的。d一 定义后,正是一条狗了
# 那正是面向对象设计

 

通过多少个函数式编号演进,精晓面向对象设计 def0一.py ① dog一 = { 2 ‘ name ‘
: ‘ 元昊…

面向进度 VS 面向对象

面向进度的先后设计的主干是经过(流水生产线式思维),进程即消除难点的步骤,面向进程的陈设性就好比精心设计好一条流水生产线,思量周密哪一天管理什么事物。

亮点是:十分大的下挫了写程序的复杂度,只要求顺着要举办的手续,积聚代码就能够。

缺陷是:一套流水生产线或许流程正是用来缓慢解决叁个难题,代码牵一发而动全身。

利用场景:一旦变成人中学央很少改动的景观,盛名的事例有Linux內核,git,以及Apache
HTTP Server等。

 

面向对象的程序设计的主干是目的(上帝式思维),要了然对象为什么物,必须把自身真是上帝,上帝眼里俗世存在的万物皆为目标,不设有的也足以成立出来。面向对象的次序设计好比方来统一筹算西游记,世尊要消除的标题是把经书传给东土大唐,释迦牟尼想了想化解这几个难题须求几个人:唐三藏,沙悟净,猪捌戒,孙行者,种种人都有各自的表征和技能(那正是目的的概念,特征和能力分别对应对象的习性和方法),可是这并不佳玩,于是世尊又布置了一堆妖鬼怪怪,为了防备师傅和徒弟五个人在取经路上被搞死,又安插了一批神明保驾保护航行,那一个都以目的。然后取经起始,师傅和徒弟五个人与妖鬼怪怪佛祖相互缠斗着直到最后得到真经。释迦牟尼佛根本不会管师傅和徒弟几个人根据什么流程去取。

面向对象的主次设计的

优点是:消除了先后的扩张性。对某叁个对象单独修改,会立时反映到一切体系中,如对娱乐中一人物参数的风味和手艺修改都很轻易。

缺陷:可控性差,不可能向面向进程的主次设计流水生产线式的能够很精准的预测难点的拍卖流程与结果,面向对象的次第三旦早先就由对象时期的竞相解决难题不怕是上帝也无能为力臆想最终结出。于是我们平时见到2个玩耍人某一参数的修改极有异常的大恐怕导致阴霸的技巧出现,壹刀砍死4个人,这么些游乐就失去平衡。

动用场景:须要常常转移的软件,一般需求的调换都聚集在用户层,互连网应用,公司内部软件,游戏等都以面向对象的主次设计大显身手的好地点。

在python 中面向对象的顺序设计并不是全体。

面向对象编制程序能够使程序的掩护和扩张变得更简短,并且能够大大提升程序支付效能,别的,基于面向对象的顺序能够使它人尤为轻巧明白你的代码逻辑,从而使集团开销变得更从容。

打听部分名词:类、对象、实例、实例化

类:具备同等特征的1类东西(人、狗、老虎)

目的/实例:具体的某2个东西(隔壁阿花、楼下旺财)

实例化:类——>对象的经过

Python 面向对象之1,python面向对象

Python 面向对象之 类与本性

   
明日触及了瞬间面向对象,发现面向对象和事先知道的简直就是南辕北辙,在学Linux的时候,1切皆文件,以后学面向对象了,so,1切皆对象。

   
从前不是一贯在学的用面向函数编制程序,用函数就能够化解1切了,不过怎么要用面向对象?面向对象呢,大大的进步了先后的可扩张性,面对不停的须要变动的时候,面向对象的优越性就显现出来了,先从面向函数来向面向对象实行过度。

先举3个例证:

# def dog(name,gender,type):
#     # 狗的动作
#     def jiao(dog):
#         print('一条狗[%s],汪汪汪' % dog['name'])  #此处可以与函数名dog或者与字典的返回值do同名都可以(最好还是要以返回值相同)
#     def chi_fan(dog):
#         print('一条[%s] 正在吃饭' % dog['type'])
#     dog = {
#         'name':name,
#         'gender': gender,
#         'type': type,
#         'jiao':jiao,
#         'chi_shi':chi_fan,
#     }
#     return dog
# d1=dog('牛逼','公','中华犬')
输出的结果:

#{'name': '牛逼', 'gender': '公', 'type': '中华犬', 'jiao': <function dog.<locals>.jiao at 0x005912B8>, 'chi_fan': <function dog.<locals>.chi_shi at 0x00591270>}

从地点的例子能够见到:定义了二个dog函数,在那几个函数内啊又定义了函数jiao和
chi_fan
七个函数,还定义了1个字典,在这一个字典中呢有定义dog的数目属性,比如:名字,性别等,还有函数属性
叫和用膳,在函数最终有2个回去值return 再次来到的吧是dog
这几个字典,打字与印刷d一的数值就会开采:得到的是贰个字典类型的数据,在那之中等学校函授数属性再次回到的是函数的内部存储器地址。

在此基础上海展览中心开核查:

def dog(name,gender,type):
#     # 狗的动作
#     def jiao(dog):
#         print('一条狗[%s],汪汪汪' % dog['name'])
#     def chi_fan(dog):
#         print('一条[%s] 正在吃饭' % dog['type'])
#     def init(name,gender,type):#狗的属性和狗的方法(将返回值也做成一个方法来使用)
#         dog1 = {
#             'name':name,
#             'gender': gender,
#             'type': type,
#             'jiao':jiao,
#             'chi_shi':chi_fan,
#         }
#         return dog1
#     return init(name,gender,type)  # (将函数名当参数进行传递)
#
# d1=dog('牛逼','公','中华犬')
# print(d1)
# d1['jiao'](d1)   #jiao 函数需要传入参数,参数为d1这个狗


输出结果:一条狗[牛逼],汪汪汪

那3回是在前边的底蕴上把再次回到值做成贰个init的函数通过这么些函数来进行字典里面包车型大巴始末,尽管要调用定义def
dog中的方法,调用方式为:d1[‘jiao’](d1)
#调用字典的值加括号举行运此函数。

是还是不是依旧面向函数完毕了把dog
的天性和办法封装在函数中贯彻了,好了接下去用面向对象来得以落成上述的效应:

class Dog:
    def __init__(self,name,gender,type):
        self.name = name
        self.gender = gender
        self.type = type
    def jaio(self,):
        print('一条叫%s 的狗在大声的叫'%(self.name))

    def chi_fan(self,):
        print('一条叫%s 的狗在吃饭'%(self.name))

d1 = Dog('牛逼','male','公')
print(d1) # <__main__.Dog object at 0x004D6690>
print(d1.__dict__) # {'name': '牛逼', 'gender': 'male', 'type': '公'}
d1.chi_fan() # 一条叫牛逼 的狗在吃饭

好以往总括一下,类:便是把1类东西的平等特征和动作结合在1块儿正是类,类就是2个抽象概念。对象:正是依靠类创制的1个有血有肉的东西(具体存在的),也是把动作和特色结合在壹块。

接下去看一下类的数码属性和函数属性:

class Chinese:
    '中国人的类'
    ren='中国人'
    def watch_tv(self):
        print('好牛逼的剧')
    def cha_dui(self):
        print('插到了前面')

print(Chinese.ren)
Chinese.watch_tv('kjk')
Chinese.cha_dui('就是你')
#
print(dir(Chinese)) #查看存在的方法
print(Chinese.__dict__) #查看类的属性字典
print(Chinese.__dict__['ren'])
Chinese.__dict__['watch_tv'](1)
Chinese.__dict__['cha_dui'](1)

#输出结果为:中国人
好牛逼的剧
插到了前面
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'cha_dui', 'ren', 'watch_tv']
{'__module__': '__main__', '__doc__': '中国人的类', 'ren': '中国人', 'watch_tv': <function Chinese.watch_tv at 0x008112B8>, 'cha_dui': <function Chinese.cha_dui at 0x00811270>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>}
中国人
好牛逼的剧
插到了前面

类属性的增加和删除改查:

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name))
#查看
print(Chinese.country)
#
# #修改
Chinese.country='Japan'
print(Chinese.country)
#
p1=Chinese('alex')
print(p1.__dict__)#返回的是p1对象中init中存储的字典数据属性
print(p1.country) #首先在p1的数据属性中找若此数值不存在则在类的数据属性中找
#
# #增加
Chinese.ren='中国人'
#
print(Chinese.ren)
print(p1.ren) #首先在p1的数据属性中找若此数值不存在则在类的数据属性中找

# #删除
del Chinese.ren
del Chinese.country
#
# print(Chinese.__dict__)
# print(Chinese.country)  #AttributeError: type object 'Chinese' has no attribute 'country'


#增加方法
def eat_food(self,food):
    print('%s 正在吃%s' %(self.name,food))
#
Chinese.eat=eat_food  #{'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x021E1300>, 'play_ball': <function Chinese.play_ball at 0x021E12B8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, 'eat': <function eat_food at 0x021E1348>}
#
print(Chinese.__dict__)
p1.eat('饭') #alex 正在吃饭
#

实例属性的增加和删除改查:

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

p1=Chinese('牛逼') #实例化一个对象p1
print(p1.__dict__) #打印p1中存在的所有属性(实例化对象中只存在数值型属性)

#查看
print(p1.name)
print(p1.play_ball) # bound method Chinese.play_ball of <__main__.Chinese object at 0x00426690>>

# #增加
p1.age=18
print(p1.__dict__)
print(p1.age)
#

#
# #修改
p1.age=19
print(p1.__dict__)
print(p1.age)
#
# #删除
del p1.age
print(p1.__dict__)

获得类属性和实例化的性情比方:

class Chinese:
    country='China'
    l=['a','b']
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('sb')
print(p1.l) #现去p1的init中找,若没有就会去类Chinese中去找类的数据属性
p1.l=[1,2,3] #是给实例化对象p1中添加一个数据属性 'l': [1, 2, 3]
print(Chinese.l) #['a', 'b']
print(p1.__dict__) #{'name': 'sb', 'l': [1, 2, 3]}
p1.l.append('c')
print(p1.__dict__) #{'name': 'sb', 'l': [1, 2, 3, 'c']}
print(Chinese.l) #['a', 'b']


country='中国-------------------'
class Chinese:
    country='中国'
    def __init__(self,name):
        self.name=name
        print('--->',country)

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

#print(Chinese.__dict__)  # {'__module__': '__main__', 'country': '中国', '__init__': <function Chinese.__init__ at 0x006E1300>, 'play_ball': <function Chinese.play_ball at 0x006E12B8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}
#print(Chinese.country)  #中国
p1=Chinese('sb') #---> 中国-------------------
print('实例--------》',p1.country) #实例--------》 中国

#注意:通过点(.)来访问变量时在类class中去寻找,而一般变量不是通过实例化对象或类名点的方式去访问,则这个是在类的外面去寻找这个变量。

 

面向对象之1,python面向对象 Python
面向对象之 类与属性
明日触及了弹指间面向对象,开采面向对象和此前知道的简直正是风马牛不相及,…

def01.py

初识类和对象

python中漫天皆为目的,类型的真面目就是类

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

从上边的事例来看,字典正是1类数据结构,笔者1说字典你就精晓是十三分用{}表示,里面由k-v键值对的东西,它还富有局地增加和删除改查的格局。不过自己一说字典你能领略字典里具体存了怎么样内容么?不可能,所以大家说对于三个类来说,它具有同样的本性属性和办法。

而实际的{‘name’:’eva’}那些字典,它是1个字典,能够利用字典的全体办法,并且在那之中有了切实的值,它正是字典的2个对象。对象正是1度确实存在的某多个切实可行的民用。

 

再举叁个别样的例证,通俗一点,举例您以往有一个动物园,你想描述那个动物园,那么动物园里的每一种动物就是贰个类,老虎、天鹅、鳄鱼、熊。他们都有同等的质量,举个例子身高体重出生时间和种类,还有各样动作,举个例子鳄鱼会游泳,天鹅会飞,老虎会跑,熊会吃。

但是那几个老虎熊啥的都不是有血有肉的某多头,而是一类动物。即使他们都有身高体重,可是你却未曾艺术分明那几个值是有个别。假如那年给你3只具体的老虎,而你还没死,那您就能给她量量身高称称体重,那么些数值是否就改为现实的了?那么具体的这一头老虎正是二个切实的实例,也是2个目标。不止这1只,其实每二头具体的老虎都有谈得来的身高体重,那么每1只猛虎都以老虎类的一个目的。

在python中,用变量表示特征,用函数表示手艺,由此具备相同特征和技术的一类东西就是‘类’,对象是则是那1类东西中实际的2个。

 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)

类的相干文化

 def02.py

初识类

 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

类有二种功能:属性引用和实例化

 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 ,

 天性引用(类名.属性)

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


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

 

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

金沙注册送58 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)  #引用人的走路方法,注意,这里不是在调用

金沙注册送58 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,修改以往不便于识别。

# 那么贰个函数,
#
就是给定不一致属性,设置属性到它当中,
#
并且它个中的函数使用了那几个属性,完成了新的动作,
#
通过再次来到方法至三个字典其中,让外部调用这几个方法(属性和艺术都供给让外部去拜访,在字典类型当中来讲,是同等的),
#
即完毕了所谓的【面向对象】

类属性的补偿

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

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

#
对象在不描述以前什么都不是。
#
对象正是急需描述它的动作和特征,才能去定义它。比如:人,长什么样,能做什么;灯泡,是何等,能做哪些。

对象的连带知识

#
类是架空的,唯有属性和格局。 dog()函数就是
#
但对象是透过动作和脾气的概念的。d一 定义后,正是一条狗了
# 那就是面向对象设计

目的是有关类而实际存在的一个例证,即实例

类就像是模板,定义后正是2个目的了。

目的/实例唯有1种效用:属性引用

金沙注册送58 3金沙注册送58 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)

人狗战斗

也能够引用贰个方法,因为方法也是壹天性能,只然则是3个近乎函数的特性,大家也管它叫动态属性。
引用动态属性并不是举办这几个主意,要想调用方法和调用函数是一样的,都亟需在后头加上括号

print(egg.attack)

自笔者精晓在类里说,你恐怕还有多数地方不能够清楚。那我们就用函数来解释一下那几个类呀,对象啊到底是个吗,你悄悄的用这一个精通就好了,不要告诉外人

金沙注册送58 5金沙注册送58 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'])

帮忙理解面向对象

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

金沙注册送58 7金沙注册送58 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   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

小结

金沙注册送58 9金沙注册送58 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()

习题


类—–产生—–对象的历程叫抓实例化(实例=对象)

目标之间的竞相

人狗战斗之血腥互搏

金沙注册送58 11金沙注册送58 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点血

 

完全的代码

金沙注册送58 13金沙注册送58 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点血

人狗互搏之孰生孰死

金沙注册送58 15金沙注册送58 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,找不到则去类中找,类也找不到就找父类…最终都找不到就抛出十三分

 

面向对象的组成用法

软件重用的根本方法除了继续之外还有其余1种办法,即:组合

重组指的是,在三个类中以别的2个类的目的作为数据属性,称为类的构成

金沙注册送58 17金沙注册送58 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来使用组合类中的所有方法

构成示例

圆环是由七个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是在那之中圆的周长加上国外国语大学表圆的周长。
其暂时候,我们就率先落到实处二个圆形类,总括2个圆的周长和面积。然后在”环形类”中结合圆形的实例作为本身的性质来用

金沙注册送58 19金沙注册送58 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课程

金沙注册送58 21金沙注册送58 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

当类之间有威名昭著差异,并且一点都不大的类是十分的大的类所必要的机件时,用整合相比较好

初识面向对象小结

金沙注册送58 23金沙注册送58 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大特征

继承

如何是持续

承继是一种创立新类的点子,在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.将人,猪,狗那四个类相比较像的1部分抽出成父类。

空洞最首要的效劳是分开连串(能够凝集关切点,降低复杂度)

金沙注册送58 25

此起彼伏:是基于抽象的结果,通过编制程序语言去实现它,显明是先经历抽象那个进度,才具因而持续的秘籍去表述出抽象的结构。

抽象只是分析和安排性的历程中,贰个动作恐怕说1种技巧,通过架空能够获取类

金沙注册送58 26

接轨与重用性

金沙注册送58 27金沙注册送58 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有个别设置超过半数,大大生了编制程序职业量,那便是常说的软件重用,不仅能够重用自身的类,也能够持续外人的,比方标准库,来定制新的数据类型,这样正是大大缩小了软件开辟周期,对大型软件开垦来说,意义重大.

派生

子类也得以加上本人新的性情或然在融洽那里再度定义那几个属性(不会潜移默化到父类),要求注意的是,1旦重新定义了投机的性质且与父类重名,那么调用新添的性质时,就以温馨为准了。

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参数也要为其传值.

在python三中,子类实施父类的章程也足以直接用super方法.

金沙注册送58 29金沙注册送58 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()

帮你领悟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()

由此持续建立了派生类与基类之间的涉及,它是1种’是’的涉及,举例白马是马,人是动物。

当类之间有多数平等的效益,提取这么些共同的意义做成基类,用持续相比好,举个例子教授是师资

>>> 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

抽象类与接口类

接口类

延续有三种用途:

1:承袭基类的办法,并且做出本身的转移依然扩充(代码重用)  

二:申明有个别子类包容于某基类,定义1个接口类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() #不调就报错了

施行中,继承的率先种意义意义并不一点都不小,乃至不时是加害的。因为它使得子类与基类出现强耦合。

此起彼伏的第一种意义卓殊首要。它又叫“接口承袭”。
接口承继实质上是须要“做出一个可观的抽象,那一个抽象规定了一个相称接口,使得外部调用者无需关怀具体细节,可并排的管理达成了一定接口的具备目的”——那在程序设计上,叫做归一化。

归1化使得高层的外表使用者能够不加区分的拍卖全体接口包容的靶子集合——就好象linux的泛文件概念一样,全部东西都能够当文件管理,不必关心它是内存、磁盘、互连网也许显示器(当然,对底层设计者,当然也足以分别出“字符设备”和“块设备”,然后做出针对性的陈设:细致到怎样程度,视供给而定)。

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

在python中根本就不曾1个称为interface的关键字,下边包车型客车代码只是看起来像接口,其实并未起到接口的效益,子类完全能够不用去实现接口 ,如果非要去模仿接口的概念,能够重视第壹方模块:

twisted的twisted\internet\interface.py里使用zope.interface

文档

设计形式:

金沙注册送58 31金沙注册送58 32

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

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

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

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

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

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

怎么要用接口

抽象类

什么是抽象类

*   
与java同样,python也有抽象类的定义但是一样必要依据模块达成,抽象类是五个独特的类,它的独特之处在于只可以被持续,不可能被实例化*

何以要有抽象类

   
如果说类是从一堆对象中抽出一样的始末而来的,那么抽象类是从一堆中收取一样的始末而来的,内容蕴涵数据属性和函数属性。

* 
比方大家有美蕉的类,有苹果的类,有水蜜桃的类,从那么些类收取一样的内容正是鲜果那么些抽象的类,你吃水果时,要么是吃二个有血有肉的金蕉,要么是吃1个切实可行的黄肉桃。。。。。。你永恒不只怕吃到3个叫做水果的事物。*

*   
从规划角度去看,假若类是从现实对象抽象而来的,那么抽象类就是基于类华而不实而来的。*

* 
从贯彻角度来看,抽象类与普通类的区别之处在于:抽象类中有抽象方法,该类无法被实例化,只好被一连,且子类必须达成抽象方法。那或多或少与接口有点类似,但实则是例外的,就要公布答案*

在python中落到实处抽象类

金沙注册送58 33金沙注册送58 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

抽象类与接口类

抽象类的本质依旧类,指的是1组类的相似性,包含数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

抽象类是两个在于类和接口直接的贰个概念,同时具备类和接口的有个别特性,能够用来贯彻归一化设计 

在python中,并不曾接口类那种事物,就算不通过专门的模块定义接口,大家也理应有一部分焦点的定义。

一.多再三再四难点

在此起彼伏抽象类的经过中,我们相应尽量制止多一而再;
而在继续接口的时候,大家反而鼓励你来多一而再接口

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

二.艺术的贯彻

在抽象类中,我们得以对有个别华而不实方法做出基础完结;
而在接口类中,任何措施都只是壹种标准,具体的作用须要子类落成

钻石承接

持续顺序

金沙注册送58 35

 

金沙注册送58 36金沙注册送58 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到底是如何达成持续的,对于你定义的每1个类,python会总结出贰个艺术分析顺序(MRO)列表,那几个MRO列表就是1个差不离的具有基类的线性顺体系表,举例

>>> 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列表上从左到右初叶查找基类,直到找到第2个地位相当那特特性的类截至。
而以此MRO列表的布局是由此1个C三线性化算法来得以完成的。大家不去探究这几个算法的数学原理,它事实上正是联合全数父类的MRO列表并根据如下3条规则:
一.子类会先于父类被检查
二.七个父类会依据它们在列表中的顺序被检查
3.要是对下三个类存在多个合法的挑3拣肆,采纳第叁个父类

持续小结

接轨的功力

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

多少个名词

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

抽象类与接口类

金沙注册送58 38

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


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

金沙注册送58 39

钻石传承

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

多态

多态

多态指的是一类东西有四种样子

动物有各种造型:人,狗,猪

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')

多态性

1 什么是多态动态绑定(在继续的背景下行使时,有时也称之为多态性)

多态性是指在不考虑实例类型的事态下行使实例

#在面向对象方法中一般是这样表述多态性:
#向不同的对象发送同一条消息(!!!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技师经常依照那种行为来编写程序。举例,若是想编写现成对象的自定义版本,能够持续该对象

也足以创立3个外观和行事像,但与它无其余涉及的全新对象,后者经常用于保存程序组件的松耦合度。

例一:利用标准库中定义的各样‘与公事类似’的对象,尽管那么些目的的做事方法像文件,但她们从没持续内置文件对象的主意

例二:类别类型有三种形状:字符串,列表,元组,但她俩直白未有一直的承袭关系

金沙注册送58 40金沙注册送58 41

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

    def write(self):
        pass

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

例子

封装

【封装】

         隐藏对象的品质和落成细节,仅对外提供公共访问格局。

【好处】 

  1. 将扭转隔开; 

  2. 福利使用;

  3. 加强复用性; 

  4. 提升安全性;

【封装原则】

      一. 将不要求对外提供的故事情节都藏匿起来;

      二. 把质量都掩藏,提供公共措施对其访问。

个体变量和个体方法

在python中用双下划线开头的方法将质量隐藏起来(设置成私有的)

民用变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__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只辛亏其间采用,如self.__x,**引用的便是变形的结果金沙注册送58,**。

二.那种变形其实正是针对外部的变形,在表面是无力回天透过__x那个名字访问到的。

三.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变产生了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开首的属性在延续给子类时,子类是无力回天掩盖的。**

 

那种变形须要小心的难点是:

壹.那种机制也并未有当真意义上限制咱们从外表直接待上访问属性,知道了类名和属性名就能够拼盛名字:_类名__属性,然后就足以访问了,如a._A__N

二.变形的历程只在类的里边生效,在概念后的赋值操作,不会变形

金沙注册送58 42

个人方法

三.在继续中,父类假若不想让子类覆盖自身的诀要,能够将艺术定义为私有的

#正常情况
>>> 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是一种特殊的品质,访问它时会实践1段功效(函数)然后再次回到值

#例一: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)

金沙注册送58 43金沙注册送58 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
'''

例2:圆的周长和面积

何以要用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二种方法

金沙注册送58 45金沙注册送58 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

金沙注册送58 47金沙注册送58 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     # 删除商品原价

classmethod

class Classmethod_Demo():
    role = 'dog'

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

Classmethod_Demo.func()

staticmethod

class Staticmethod_Demo():
    role = 'dog'

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

Staticmethod_Demo.func()

面向对象的更加多表达

面向对象的软件开拓

不少人在学完了python的class机制之后,蒙受三个生育中的难点,依旧会懵逼,那事实上太健康了,因为此外程序的费用都以先规划后编程,python的class机制只然而是1种编制程序情势,借使你硬要拿着class去和你的主题材料死磕,变得更其懵逼都以分分钟的事,在原先,软件的付出相对轻巧,从职责的解析到编写程序,再到程序的调养,能够由壹人或一个小组去实现。可是随着软件规模的急速增大,软件大四面临的主题素材十三分复杂,供给思虑的要素太多,在八个软件中所发生的不当和藏身的荒唐、未知的荒唐大概高达惊人的程度,那也不是在设计阶段就完全化解的。

   
所以软件的开销其实一整套行业内部,大家所学的只是里面包车型客车一小部分,一个总体的支出进度,须要明确每一个阶段的任务,在有限支撑二个阶段正确的前提下再开始展览下一个级其他办事,称之为软件工程

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

一.面向对象分析(object oriented analysis ,OOA)

   
软件工程中的系统分析阶段,要求分析员和用户结成在一同,对用户的须要做出确切的分析和鲜明的表达,从大的上面剖析软件系统应该做哪些,而不是怎么去做。面向对象的解析要依照面向对象的概念和艺术,在对义务的分析中,从客观存在的东西和东西之间的关联,贵南出有关的对象(对象的‘特征’和‘才具’)以及对象之间的关系,并将具备同等属性和行为的靶子用1个类class来标记。

    建立贰个能反映这是办事状态的须要模型,此时的模型是回顾的。

贰 面向对象设计(object oriented design,OOD)

    依照面向对象分析阶段变成的供给模型,对每一部分各自进行具体的设计。

   
首先是类的图谋,类的准备或许含有五个档期的顺序(利用一连与派生机制)。然后以那么些类为基础提议程序设计的思绪和方式,包蕴对算法的设计。

   
在设计阶段并不牵扯任何一门具体的微管理器语言,而是用一种更通用的讲述工具(如伪代码或流程图)来描述

三 面向对象编程(object oriented programming,OOP)

    依照面向对象设计的结果,选择一种计算机语言把它写成程序,能够是python

肆 面向对象测试(object oriented test,OOT)

   
在写好程序后提交用户使用前,必须对先后开始展览严峻的测试,测试的目标是开掘先后中的错误并改进它。

    面向对的测试是用面向对象的秘诀举办测试,以类作为测试的着力单元。

五 面向对象维护(object oriendted soft maintenance,OOSM)

   
正如对其余产品都亟需开始展览售后服务和护卫一样,软件在利用时也会并发一些主题素材,或然软件商想立异软件的属性,那就必要修改程序。

    由于采纳了面向对象的艺术开垦顺序,使用程序的保安相比较易于。

   
因为对象的封装性,修改一个目的对其他的目标影响十分小,利用面向对象的点子维护程序,大大升高了软件维护的频率,可扩大性高。

 

   
在面向对象方法中,最早发展的早晚是面向对象编制程序(OOP),那时OOA和OOD都还尚无发展兴起,由此先后设计者为了写出面向对象的主次,还必须长远到剖析和安插领域,更加是安排性领域,那时的OOP实际上包罗了今后的OOD和OOP七个阶段,那对先后设计者必要比较高,许四人备感很难调控。

   
未来统筹四个大的软件,是从严遵守面向对象软件工程的多少个阶段张开的,这些多少个品级的工作不是由一个人从头到尾完毕的,而是由不一致的人各自产生,那样OOP阶段的任务就比较轻便了。程序编写者只须求根据OOd提出的思绪,用面向对象语言编写出程序既可。

    在四个大型软件开荒进度中,OOP只是十分小的3个片段。

   
对于全栈开辟的您的话,那三个阶段都有了,对于简易的主题材料,不必严刻遵从这些四个级次实行,往往由程序设计者遵照面向对象的不二等秘书籍开始展览程序设计,包罗类的设计和次序的宏图

 

多少个概念的证实

 

一.面向对象的次序设计看起来高大上,所以小编在编制程序时就应该保险通篇class,这样写出的程序一定是好的顺序(面向对象只适合这么些可扩大性要求相比高的情景)

2.居五人欢跃说面向对象三大特点(那是从哪传出来的,封装,多态,承接?漏洞太多太多,好吧暂时称为3大特征),那么本身在依照面向对象编制程序时,小编自然要让自家定义的类中总体的隐含那二种天性,那样写一定是好的顺序

好东西,小编说降龙拾八掌有拾8掌,那么您每一遍跟人干仗都要从第贰掌打到第二八掌那才显示你会了是么:面对仇人,你打到第二掌对方就早已倒下了,你说,不行,你给老子起来,老子还并未show完…

三.类有类性子,实例有实例属性,所以大家在定义class时确定要定义出那么几个类属性,想不到如何做,这就全力以赴的想,定义的更加多越牛逼

那就犯了二个严重的失实,程序越早面向对象,死的越早,为何面向对象,因为大家要将数据与效果整合到2只,程序全部的协会都未曾出来,大概说要求思虑的标题你都不曾搞通晓个8九不离10,你就从头面向对象了,那就导致了,你在那边干想,自认为想通了,定义了一群属性,结果后来又都用不到,也许想不通到底应该定义啥,那就直接想呢,想着想着就疯了。

您见过哪家公司要开垦三个软件,上来就开首写,肯定是屡屡的开会研商陈设,请看第十节。

面向对象常用术语

抽象/实现

空洞指对现实世界难点和实业的面目表现,行为和特性建立模型,建立贰个休戚相关的子集,能够用来
绘程序结构,从而落成那种模型。抽象不仅包蕴那种模型的数据属性,还定义了这几个数据的接口。

对某种抽象的贯彻正是对此数额及与之有关接口的现实化(realization)。现实化那几个历程对于客户
程序应当是透明而且毫不相关的。 

封装/接口

装进描述了对数码/信息实行隐蔽的观念意识,它对数据属性提供接口和走访函数。通过其余客户端间接对数据的拜会,无视接口,与封装性都是反其道而行之的,除非程序猿允许这一个操作。作为完成的
壹部分,客户端根本就不需求理解在包装之后,数据属性是什么协会的。在Python中,全数的类属性都以大庭广众的,但名字大概被“混淆”了,以阻止未经授权的造访,但仅此而已,再未有此外防范措施了。那就必要在设计时,对数码提供对应的接口,避防客户程序通过不正规的操作来存取封装的多寡属性。

瞩目:封装绝不是相等“把不想让旁人看来、今后恐怕改变的东西用private隐藏起来”

的确的包装是,经过深远的思维,做出优异的肤浅,给出“完整且最小”的接口,并使得内部细节能够对外透明

(注意:对外透明的乐趣是表面调用者能够顺遂的收获和煦想要的此外意义,全然意识不到中间细节的留存)

合成

合成扩张了对类的
述,使得三个不等的类合成为壹个大的类,来消除具体主题素材。合成 述了
三个那多少个复杂的种类,举例一个类由其余类组成,越来越小的机件也或然是此外的类,数据属性及表现,
全部那么些合在一齐,互相是“有2个”的关系。

派生/承继/承继结构

派生描述了子类衍生出新的风味,新类保留已存类类型中存有须求的多寡和表现,但允许修改只怕其余的自定义操作,都不会修改原类的定义。
接轨描述了子类属性从祖先类承袭那样①种方法
承继结构意味着多“代”派生,能够述成二个“族谱”,三番五次的子类,与祖先类都有提到。

泛化/特化

据他们说承继
泛化表示全部子类与其父类及祖先类有同样的特征。
特化描述全部子类的自定义,相当于,什么性质让它与其祖先类分化。

多态与多态性

多态指的是同1种东西的多种动静:水那种东西有四种分化的场合:冰,水蒸气

多态性的概念建议了目标怎样通过他们一同的属性和动作来操作及走访,而不需考虑他们切实的类。

冰,水蒸气,都持续于水,它们都有2个同名的方法便是形成云,可是冰.变云(),与水蒸气.变云()是全然分化的进度,尽管调用的办法都1模同样

自省/反射

扪心自问也称作反射,那天个性体现了某目的是什么样在运转期获得自身音信的。假诺传一个对象给您,你能够摸清它有如何力量,那是一项庞大的风味。假使Python不支持某种方式的反思作用,dir和type内建函数,将很难不荒谬办事。还有这一个特殊品质,像__dict__,__name__及__doc__

相关文章

网站地图xml地图