【亚洲必赢官网】python函数的面向对象,python面向对象设计

因此多少个函数式编号演进,精通面向对象设计

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一 定义后,就是一条狗了
# 那正是面向对象设计

 

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

面向进度 VS 面向对象

面向进程的次序设计的着力是经过(流水生产线式思维),进程即消除难点的步骤,面向进程的规划就好比精心设计好一条流水生产线,考虑周详何时管理什么事物。

可取是:比相当大的回落了写程序的复杂度,只必要顺着要实行的手续,聚积代码就能够。

症结是:一套流水生产线恐怕流程便是用来消除3个标题,代码牵一发而动全身。

动用场景:一旦成功核心很少退换的光景,闻名的例证有Linux內核,git,以及Apache
HTTP Server等。

 

面向对象的先后设计的着力是目标(上帝式思维),要知道对象为什么物,必须把温馨当成上帝,上帝眼里世间存在的万物皆为目的,不设有的也得以创制出来。面向对象的程序设计好比如来统一筹算西游记,释迦牟尼佛要消除的主题材料是把经书传给东土大唐,世尊想了想解决这一个标题亟需多个人:三藏法师,沙悟净,猪八戒,孙猴子,每一种人都有各自的特点和技能(这就是目标的概念,特征和技术分别对应对象的个性和章程),然则那并倒霉玩,于是世尊又陈设了一批妖魔鬼怪,为了防备师傅和徒弟四个人在取经路上被搞死,又安排了一批神明保驾保护航行,那个都以目的。然后取经开头,师傅和徒弟两人与妖魔鬼怪神明相互缠斗着直到最终获得真经。释迦牟尼佛根本不会管师傅和徒弟四个人根据什么流程去取。

面向对象的次第设计的

可取是:消除了先后的扩大性。对某贰个目的单独修改,会立刻反映到任何系统中,如对游乐中一人士参数的性状和技术修改都很轻易。

缺点:可控性差,不可能向面向进程的次序设计流水生产线式的能够很精准的前瞻难点的拍卖流程与结果,面向对象的程序1旦先导就由对象之间的互相化解难题即正是上帝也无能为力预测最后结果。于是大家平时看看一个嬉戏人某一参数的修改极有非常大希望引致阴霸的本事现身,一刀砍死多少人,这么些娱乐就失去平衡。

应用场景:要求平日变化的软件,一般要求的变化都集聚在用户层,网络选取,集团中间软件,游戏等都以面向对象的次第设计大显身手的好地方。

在python 中面向对象的先后设计并不是漫天。

面向对象编制程序能够使程序的护卫和庞大变得更简便,并且能够大大提升程序支付功效,其它,基于面向对象的先后能够使它人越来越便于掌握您的代码逻辑,从而使协会支付变得更从容。

叩问一些名词:类、对象、实例、实例化

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

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

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

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

Python 面向对象之 类与品质

   
明天触及了须臾间面向对象,发现面向对象和以前知道的简直正是天冠地屦,在学Linux的时候,一切皆文件,未来学面向对象了,so,一切皆对象。

   
在此之前不是间接在学的用面向函数编制程序,用函数就足以解决一切了,可是为啥要用面向对象?面向对象呢,大大的提升了先后的可扩展性,面对不停的急需变动的时候,面向对象的优越性就展现出来了,先从面向函数来向面向对象举行过度。

先举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
七个函数,还定义了2个字典,在那些字典中吗有定义dog的多少属性,举例:名字,性别等,还有函数属性
叫和就餐,在函数最终有三个赶回值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这个狗


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

这一回是在前头的根基上把重临值做成多个init的函数通过那个函数来试行字典里面包车型客车内容,固然要调用定义def
dog中的方法,调用格局为:d壹[‘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() # 一条叫牛逼 的狗在吃饭

好未来总括一下,类:正是把一类东西的同样特征和动作结合在共同正是类,类正是三个抽象概念。对象:正是基于类创制的三个实际的事物(具体存在的),也是把动作和特色结合在一同。

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

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中去寻找,而一般变量不是通过实例化对象或类名点的方式去访问,则这个是在类的外面去寻找这个变量。

 

面向对象之一,python面向对象 Python
面向对象之 类与属性
前日触及了瞬间面向对象,发现面向对象和事先知道的大约正是天渊之隔,…

def01.py

初识类和目的

python中整整皆为目标,类型的本色正是类

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

从上边的事例来看,字典正是1类数据结构,作者一说字典你就了然是非凡用{}表示,里面由k-v键值对的东西,它还富有部分增加和删除改查的艺术。可是本人壹说字典你能驾驭字典里具体存了怎么样内容么?无法,所以大家说对于1个类来说,它兼具一样的性状属性和艺术。

而实际的{‘name’:’eva’}那个字典,它是2个字典,能够动用字典的兼具办法,并且个中有了具体的值,它正是字典的三个对象。对象就是曾经确实存在的某2个现实的私有。

 

再举一个任何的例子,通俗一点,比方你以后有3个动物园,你想描述这些动物园,那么动物园里的每一种动物就是一个类,老虎、天鹅、鳄鱼、熊。他们都有同1的性质,比如身高体重出生时间和花色,还有种种动作,比方鳄鱼会游泳,天鹅会飞,老虎会跑,熊会吃。

不过这一个老虎熊啥的都不是实际的某贰头,而是一类动物。就算他们都有身高体重,但是你却尚无艺术分明那个值是稍微。假使那一年给你贰头具体的大虫,而你还没死,那你就能给她量量身高称称体重,那个数值是或不是就改为实际的了?那么具体的这一头老虎正是二个有血有肉的实例,也是一个目的。不止那二头,其实每二只具体的老虎都有投机的身高体重,那么每贰只猛虎都以老虎类的多个对象。

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

 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__函数的运行,能够用它来为各类实例定制本人的风味

亚洲必赢官网 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)  #引用人的走路方法,注意,这里不是在调用

亚洲必赢官网 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一 定义后,正是一条狗了
# 那正是面向对象设计

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

类就如模板,定义后就是三个对象了。

对象/实例唯有一种效应:属性引用

亚洲必赢官网 3亚洲必赢官网 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)

人狗战斗

也能够引用二个措施,因为方法也是1本性质,只但是是3个看似函数的属性,大家也管它叫动态属性。
引用动态属性并不是实施那些法子,要想调用方法和调用函数是如出1辙的,都急需在末端加上括号

print(egg.attack)

自家清楚在类里说,你恐怕还有繁多地点无法知道。那我们就用函数来解释一下这些类呀,对象啊到底是个吗,你悄悄的用这些精晓就好了,不要告诉外人

亚洲必赢官网 5亚洲必赢官网 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'])

扶持领悟面向对象

面向对象小结——定义及调用的定点情势

亚洲必赢官网 7亚洲必赢官网 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   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

小结

亚洲必赢官网 9亚洲必赢官网 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()

习题


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

对象时期的相互

人狗战斗之血腥互搏

亚洲必赢官网 11亚洲必赢官网 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

创立3个类(狗类)

 亚洲必赢官网 ,在python个中,未有必要您早晚要写面向对象的代码。用面向对象的语言,和2个顺序的统一打算是面对对象的,两者无任何关系。

实例化2只实实在在的狗

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

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

交互 egon打ha2一下

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

 

全部的代码

亚洲必赢官网 13亚洲必赢官网 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点血

人狗互搏之孰生孰死

亚洲必赢官网 15亚洲必赢官网 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> 

【亚洲必赢官网】python函数的面向对象,python面向对象设计。成立一个对象/实例就会成立2个目的/实例的称谓空间,存放对象/实例的名字,称为对象/实例的本性

在obj.name会先从obj自身的称呼空间里找name,找不到则去类中找,类也找不到就找父类…最终都找不到就抛出异常

 

面向对象的三结合用法

软件重用的严重性措施除了再三再四之外还有别的一种艺术,即:组合

组成指的是,在2个类中以其余二个类的目的作为数据属性,称为类的三结合

亚洲必赢官网 17亚洲必赢官网 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来使用组合类中的所有方法

重组示例

圆环是由多少个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是中间圆的周长加上国外国语大学表圆的周长。
以此时候,我们就率先实现叁个圆形类,总结三个圆的周长和面积。然后在”环形类”中结合圆形的实例作为谐和的本性来用

亚洲必赢官网 19亚洲必赢官网 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课程

亚洲必赢官网 21亚洲必赢官网 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

当类之间有综上说述区别,并且很小的类是相当的大的类所急需的零件时,用整合相比较好

初识面向对象小结

亚洲必赢官网 23亚洲必赢官网 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不敌狡猾的人类用武器取胜,血槽空了一半

打闹小例

遵照那种思路一点一点的设计类和对象,最后完全能够兑现一个完美的对阵类游戏。

面向对象的三大特色

继承

何以是三番五次

继续是1种创制新类的办法,在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.将人,猪,狗那个类相比像的有的抽取成父类。

空泛最根本的意义是分开种类(可以凝集关心点,降低复杂度)

亚洲必赢官网 25

一而再:是凭仗抽象的结果,通过编制程序语言去得以完毕它,肯定是先经历抽象这么些进程,技能因而持续的主意去抒发出抽象的结构。

架空只是分析和规划的进程中,3个动作或许说1种技艺,通过架空能够获得类

亚洲必赢官网 26

承接与重用性

亚洲必赢官网 27亚洲必赢官网 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()

提示:用早已有的类建立3个新的类,那样就选定了壹度局地软件中的壹有的装置大多数,大大生了编制程序职业量,那正是常说的软件重用,不仅能够重用自个儿的类,也足以继续别人的,比方典型库,来定制新的数据类型,那样正是大大缩小了软件开垦周期,对大型软件开拓来讲,意义重大.

派生

子类也能够加上本人新的属性只怕在温馨那里再一次定义这么些属性(不会潜移默化到父类),必要注意的是,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参数也要为其传值.

在python3中,子类实行父类的主意也得以直接用super方法.

亚洲必赢官网 29亚洲必赢官网 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()

因此持续建立了派生类与基类之间的涉及,它是一种’是’的涉及,比方白马是马,人是动物。

当类之间有繁多同等的功能,提取那一个共同的功用做成基类,用连续相比好,举例教授是教员职员和工人

>>> 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:承继基类的方法,并且做出本人的退换依旧扩大(代码重用)  

二:申明某些子类兼容于某基类,定义一个接口类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个才子佳人接口,使得外部调用者无需关切具体细节,可并排的管理达成了一定接口的保有目标”——那在程序设计上,叫做归一化。

归1化使得高层的表面使用者可以不加区分的管理全体接口包容的目的集合——就好象linux的泛文件概念一样,全数东西都足以当文件管理,不必关怀它是内部存款和储蓄器、磁盘、互连网大概显示器(当然,对底层设计者,当然也得以分别出“字符设备”和“块设备”,然后做出针对性的规划:细致到如何程度,视须要而定)。

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

在python中平昔就从未一个誉为interface的最首要字,下边包车型地铁代码只是看起来像接口,其实并不曾起到接口的机能,子类完全能够不用去实现接口 ,假若非要去模仿接口的定义,能够注重第3方模块:

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

文档

设计格局:

亚洲必赢官网 31亚洲必赢官网 32

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

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

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

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

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

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

怎么要用接口

抽象类

哪些是抽象类

*   
与java同样,python也有抽象类的概念然则同样须求依附模块达成,抽象类是3个尤其的类,它的独特之处在于只可以被三番五次,不可能被实例化*

何以要有抽象类

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

* 
举例大家有美蕉的类,有苹果的类,有白桃的类,从这个类抽出一样的内容正是水果这么些抽象的类,你吃水果时,要么是吃贰个切实可行的西贡蕉,要么是吃三个实际的黄肉桃。。。。。。你永世不能够吃到叁个号称水果的东西。*

*   
从规划角度去看,假设类是从现实对象抽象而来的,那么抽象类正是根据类华而不实而来的。*

* 
从贯彻角度来看,抽象类与普通类的不一致之处在于:抽象类中有抽象方法,该类无法被实例化,只可以被接续,且子类必须兑现抽象方法。那或多或少与接口有点类似,但实际上是例外的,将在发表答案*

在python中落到实处抽象类

亚洲必赢官网 33亚洲必赢官网 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),而接口只重申函数属性的相似性。

抽象类是三个在于类和接口直接的1个概念,同时具有类和接口的局地性格,能够用来兑现归一化设计 

在python中,并未接口类那种事物,即使不通过专门的模块定义接口,大家也应当有局地主干的定义。

一.多接续问题

在此起彼伏抽象类的进度中,大家应当尽量制止多三番五次;
而在一连接口的时候,大家反而鼓励你来多再三再四接口

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

二.艺术的完成

在抽象类中,大家能够对一些华而不实方法做出基础完毕;
而在接口类中,任何措施都只是一种规范,具体的效能要求子类实现

钻石承继

后续顺序

亚洲必赢官网 35

 

亚洲必赢官网 36亚洲必赢官网 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列表的结构是经过二个C三线性化算法来兑现的。大家不去斟酌这些算法的数学原理,它实质上就是统一全体父类的MRO列表并遵从如下3条轨道:
1.子类会先于父类被检查
贰.多个父类会根据它们在列表中的顺序被检查
三.倘使对下三个类存在七个官方的选料,选用第2个父类

后续小结

接轨的效劳

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

多少个名词

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

抽象类与接口类

亚洲必赢官网 38

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


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

亚洲必赢官网 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工程师平时依据那种表现来编写程序。举个例子,如果想编写现存对象的自定义版本,能够一而再该目的

也得以创设一个外观和表现像,但与它无别的涉及的斩新对象,后者经常用于保存程序组件的松耦合度。

例1:利用规范库中定义的各个‘与公事类似’的靶子,固然那几个目标的专门的职业措施像文件,但她俩未尝承继内置文件对象的方法

例2:连串类型有多种模样:字符串,列表,元组,但他们直接没有直接的接轨关系

亚洲必赢官网 40亚洲必赢官网 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是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形

那种活动变形的表征:

1.类中定义的__x只能在其间使用,如self.__x,**引用的正是变形的结果**。

贰.那种变形其实正是本着外部的变形,在外表是力不从心透过__x那一个名字访问到的。

叁.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变产生了:_父类名__x,即双下滑线初阶的性质在继续给子类时,子类是力不从心掩盖的。**

 

那种变形须要小心的主题材料是:

1.那种机制也并不曾真正意义上限制我们从表面直接待上访问属性,知道了类名和质量名就能够拼出名字:_类名__质量,然后就足以访问了,如a._A__N

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

亚洲必赢官网 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是一种独特的性质,访问它时会实施一段功效(函数)然后再次来到值

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

亚洲必赢官网 43亚洲必赢官网 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

将3个类的函数定义成特色今后,对象再去选拔的时候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'

2个静态属性property本质便是贯彻了get,set,delete三种方式

亚洲必赢官网 45亚洲必赢官网 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

亚洲必赢官网 47亚洲必赢官网 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机制只可是是一种编程形式,倘若你硬要拿着class去和您的题材死磕,变得尤为懵逼都是分分钟的事,在原先,软件的开销相对简便易行,从职分的辨析到编写程序,再到程序的调护治疗,能够由1位或多少个小组去做到。但是随着软件规模的飞快增大,软件任意面临的难题十二分复杂,需求思索的因素太多,在一个软件中所爆发的错误和藏身的错误、未知的失实也许高达惊人的程度,那也不是在设计阶段就完全化解的。

   
所以软件的支出其实1整套正经,我们所学的只是当中的一小部分,二个整机的开荒进度,必要掌握每种阶段的天职,在担保多个品级精确的前提下再拓展下三个阶段的干活,称之为软件工程

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

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

   
软件工程中的系统一分配析阶段,须要分析员和用户结成在一道,对用户的需要做出确切的辨析和强烈的表述,从大的地点分析软件系统应该做什么样,而不是怎么去做。面向对象的分析要依据面向对象的定义和情势,在对职分的辨析中,从客观存在的事物和东西之间的关系,贵南出有关的目的(对象的‘特征’和‘本事’)以及对象时期的联络,并将富有同样属性和作为的对象用一个类class来标记。

    建立一个能显示那是办事状态的供给模型,此时的模子是回顾的。

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

    依照面向对象分析阶段形成的须要模型,对每1局地各自实行具体的安插性。

   
首先是类的统筹,类的统一策动大概含有多个档期的顺序(利用一连与派生机制)。然后以那么些类为基础提议程序设计的思绪和艺术,包蕴对算法的布署性。

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

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

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

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

   
在写好程序后交由用户采纳前,必须对程序进行严俊的测试,测试的目标是意识先后中的错误并纠正它。

    面向对的测试是用面向对象的秘技开始展览测试,以类作为测试的焦点单元。

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

   
正如对其他产品都需求举办售后服务和掩护同样,软件在行使时也会产出局部难点,或然软件商想革新软件的性质,那就须求修改程序。

    由于选取了面向对象的措施开采顺序,使用程序的掩护相比较便于。

   
因为对象的封装性,修改二个目标对此外的对象影响一点都不大,利用面向对象的办法维护程序,大大进步了软件维护的效能,可扩张性高。

 

   
在面向对象方法中,最早发展的终将是面向对象编制程序(OOP),那时OOA和OOD都还未有升高起来,因而先后设计者为了写出面向对象的先后,还必须深入到剖析和安排性领域,越发是布置领域,那时的OOP实际上包涵了当今的OOD和OOP八个品级,那对先后设计者要求相比高,诸多个人认为很难调节。

   
以后安排四个大的软件,是严刻根据面向对象软件工程的四个品级展开的,那几个四个级次的劳作不是由一人从头到尾达成的,而是由区别的人分头完结,那样OOP阶段的职务就相比轻便了。程序编写者只必要依附OOd建议的思绪,用面向对象语言编写出程序既可。

    在一个大型软件开采进度中,OOP只是比非常小的多个片段。

   
对于全栈开垦的您来讲,那三个阶段都有了,对于简易的主题材料,不必严苛依据这么些多少个级次打开,往往由程序设计者依据面向对象的措施实行程序设计,包蕴类的设计和次序的设计

 

多少个概念的验证

 

一.面向对象的顺序设计看起来高大上,所以本人在编制程序时就应该保障通篇class,那样写出的主次一定是好的次序(面向对象只适合那二个可扩大性供给比较高的场所)

贰.居四个人喜欢说面向对象三大特点(那是从哪传出来的,封装,多态,继承?漏洞太多太多,好吧一时称为叁大特征),那么笔者在依赖面向对象编制程序时,小编自然要让自个儿定义的类中完全的蕴藏那三种特色,那样写一定是好的次序

好东西,笔者说降龙10八掌有十捌掌,那么您每一次跟人干仗都要从第二掌打到第壹8掌那才显得你会了是么:面对仇敌,你打到第壹掌对方就早已倒下了,你说,不行,你给老子起来,老子还尚无show完…

3.类有类性质,实例有实例属性,所以大家在定义class时一定要定义出那么多少个类属性,想不到如何是好,那就用力的想,定义的更多越牛逼

那就犯了二个严重的错误,程序越早面向对象,死的越早,为何面向对象,因为大家要将数据与效果整合到手拉手,程序全部的组织都未有出去,也许说须要思量的主题材料你都未曾搞理解个8玖不离拾,你就起来面向对象了,那就产生了,你在这边干想,自认为想通了,定义了一堆属性,结果后来又都用不到,可能想不通到底应该定义啥,那就一贯想啊,想着想着就疯了。

你见过哪家公司要付出叁个软件,上来就起来写,断定是壹再的开会探讨安顿,请看第7节。

面向对象常用术语

抽象/实现

空泛指对现实世界难题和实业的九华山真面目表现,行为和性子建立模型,建立一个连锁的子集,能够用来
绘程序结构,从而达成那种模型。抽象不仅蕴涵那种模型的数额属性,还定义了那几个多少的接口。

对某种抽象的兑现就是对此数据及与之相关接口的现实化(realization)。现实化这么些进度对于客户
程序应当是晶莹而且无关的。 

封装/接口

打包描述了对数据/音信进行隐蔽的守旧,它对数码属性提供接口和做客函数。通过别的客户端直接对数码的访问,无视接口,与封装性都是违反的,除非攻城狮允许这几个操作。作为得以达成的
一部分,客户端根本就不须求知道在卷入之后,数据属性是怎么样协会的。在Python中,全数的类属性都以当着的,但名字只怕被“混淆”了,以阻挡未经授权的拜访,但仅此而已,再未有其他防范措施了。那就要求在规划时,对数码提供相应的接口,以防客户程序通过不典型的操作来存取封装的数码属性。

留神:封装绝不是相等“把不想让外人见到、以往大概退换的东西用private隐藏起来”

诚然的包装是,经过浓厚的怀念,做出雅观的用空想来欺骗别人,给出“完整且最小”的接口,并使得内部细节能够对外透明

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

合成

合成扩展了对类的
述,使得三个不等的类合成为多少个大的类,来消除具体主题材料。合成 述了
两个百般复杂的种类,举例二个类由其余类组成,越来越小的组件也也许是其余的类,数据属性及表现,
全数这几个合在一同,互相是“有叁个”的涉及。

派生/承继/继承结构

派生描述了子类衍生出新的特征,新类保留已存类类型中持有需求的数目和行为,但允许修改或然其余的自定义操作,都不会修改原类的定义。
此起彼伏描述了子类属性从祖先类承继那样一种办法
继续结构意味着多“代”派生,能够述成二个“族谱”,延续的子类,与祖先类都有涉及。

泛化/特化

依照继承
泛化表示具备子类与其父类及祖先类有同等的脾性。
特化描述所有子类的自定义,也等于,什么性质让它与其祖先类不相同。

多态与多态性

多态指的是同等种东西的多样情景:水那种东西有多样差别的事态:冰,水蒸气

多态性的概念提出了目的咋样通过他们共同的属性和动作来操作及走访,而不需思虑他们切实的类。

冰,水蒸气,都持续于水,它们都有四个同名的点子就是形成云,不过冰.变云(),与水蒸气.变云()是全然不相同的进度,固然调用的秘籍都平等

自省/反射

自省也称作反射,这几个性情体现了某目的是怎么样在运营期获得本人音讯的。假诺传一个对象给你,你能够得知它有如何力量,那是1项强大的风味。如果Python不扶助某种格局的自问功用,dir和type内建函数,将很难寻常办事。还有这一个特殊品质,像__dict__,__name__及__doc__

网站地图xml地图