威尼斯人线上娱乐

初识面向对象,面向对象设计

22 4月 , 2019  

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

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 ,

# 那么一个函数,
# 正是给定分歧性质,设置属性到它在那之中,
# 并且它里面的函数使用了这么些属性,达成了新的动作,
#
通过再次回到方法至3个字典其中,让外部调用那么些点子(属性和措施都亟待让外部去访问,在字典类型当中来讲,是一律的),
# 即落成了所谓的【面向对象】

# 对象在不描述之前什么都不是。
#
对象便是急需描述它的动作和脾气,才干去定义它。举个例子:人,长什么样,能做什么样;灯泡,是何许,能做怎么着。

# 类是架空的,只有属性和办法。 dog()函数正是
# 但对象是透过动作和本性的概念的。d1 定义后,就是一条狗了
# 那正是面向对象设计

 

通过多少个函数式编号演进,驾驭面向对象设计 def01.py 一 dog一 = { 二 ‘ name ‘
: ‘ 元昊…

面向进程 VS 面向对象

面向进度的主次设计的骨干是经过(流水线式思维),进程即消除难点的步骤,面向进度的安顿就好比精心设计好一条流水生产线,考虑周密何时管理什么事物。

亮点是:相当大的狂跌了写程序的复杂度,只须求顺着要实行的手续,堆成堆代码就可以。

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

利用场景:1旦完毕人中学央很少改造的情景,有名的例子有Linux內核,git,以及Apache
HTTP Server等。

 

面向对象的程序设计的基本是目标(上帝式思维),要理解对象为啥物,必须把本身真是上帝,上帝眼里尘凡存在的万物皆为目的,不存在的也能够创制出来。面向对象的次第设计好比方来设计西游记,释迦牟尼佛要减轻的难点是把经书传给东土大唐,如来佛想了想缓慢解决这么些题材必要两个人:唐唐三藏,沙师弟,猪八戒,美猴王,各样人都有各自的性状和才干(那就是指标的概念,特征和才能分别对应对象的脾气和办法),不过那并倒霉玩,于是释迦牟尼又安排了一堆妖妖魔怪,为了防御师傅和徒弟多个人在取经路上被搞死,又布置了一堆佛祖保驾保护航行,这几个都以目的。然后取经发轫,师傅和徒弟四个人与妖妖怪怪佛祖互相缠斗着直到最后获得真经。如来佛根本不会管师傅和徒弟四个人根据什么样流程去取。

面向对象的次序设计的

优点是:消除了程序的扩张性。对某1个对象单独修改,会立时反映到总体种类中,如对游戏中一人物参数的风味和才干修改都很轻巧。

症结:可控性差,无法向面向进度的主次设计流水生产线式的能够很精准的预测难题的管理流程与结果,面向对象的次第1旦开端就由对象时期的竞相化解难点固然是上帝也无从推断最后结出。于是我们常常见到贰个玩耍人某壹参数的改动极有十分的大可能率导致阴霸的技术出现,一刀砍死二人,那几个游乐就失去平衡。

动用场景:需要常常转移的软件,一般要求的变动都聚集在用户层,互连网接纳,企行业内部部软件,游戏等都以面向对象的次序设计大显身手的好地方。

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

面向对象编制程序能够使程序的护卫和扩大变得更简短,并且能够大大进步程序开垦成效,别的,基于面向对象的先后能够使它人愈来愈轻巧驾驭您的代码逻辑,从而使集团费用变得更从容。

打探一些名词:类、对象、实例、实例化

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

目的/实例:具体的某三个事物(隔壁阿花、楼下旺财)

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

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

Python 面向对象之 类与质量

   
明日接触了须臾间面向对象,发现面向对象和事先知道的差不多正是南辕北辙,在学Linux的时候,一切皆文件,未来学面向对象了,so,1切皆对象。

   
以前不是间接在学的用面向函数编程,用函数就足以搞定壹切了,但是为何要用面向对象?面向对象呢,大大的升高了程序的可扩张性,面对不停的供给变动的时候,面向对象的优越性就表现出来了,先从面向函数来向面向对象举办过度。

先举1个事例:

# 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
四个函数,还定义了3个字典,在那个字典中吗有定义dog的数额属性,比方:名字,性别等,还有函数属性
叫和就餐,在函数最终有3个再次来到值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中的方法,调用形式为: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() # 一条叫牛逼 的狗在吃饭

好今后总括一下,类:正是把一类东西的如出壹辙特征和动作结合在一起正是类,类正是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'

从上边的事例来看,字典正是一类数据结构,小编一说字典你就精晓是越发用{}表示,里面由k-v键值对的东西,它还持有部分增加和删除改查的点子。但是本身壹说字典你能清楚字典里具体存了何等内容么?不能,所以大家说对于贰个类来讲,它装有同样的风味属性和艺术。

而实际的{‘name’:’eva’}那一个字典,它是3个字典,可以运用字典的享有办法,并且当中有了实际的值,它就是字典的2个对象。对象正是已经确实存在的某三个现实的私房。

 

再举三个此外的例子,通俗一点,举个例子你将来有贰个动物园,你想描述那几个动物园,那么动物园里的每一种动物就是二个类,老虎、天鹅、鳄鱼、熊。他们都有雷同的脾性,比方身高体重出生时间和品种,还有种种动作,比方鳄鱼会游泳,天鹅会飞,老虎会跑,熊会吃。

而是那么些老虎熊啥的都不是实际的某3只,而是1类动物。尽管她们都有身高体重,然而你却绝非主意规定那几个值是稍微。若是这年给您叁只具体的大虫,而你还没死,这你就能给她量量身高称称体重,这几个数值是或不是就产生实际的了?那么具体的那二头老虎就是一个切实可行的实例,也是三个目的。不止那二头,其实每一头具体的老虎都有投机的身高体重,那么每3头猛虎都以老虎类的三个对象。

在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,修改今后不便于识别。

# 那么2个函数,
#
就是给定不一致属性,设置属性到它当中,
#
并且它在那之中的函数使用了那一个属性,达成了新的动作,
#
通过再次回到方法至五个字典个中,让外部调用这几个主意(属性和措施都亟需让外部去拜访,在字典类型其中来讲,是如出1辙的),
#
即达成了所谓的【面向对象】

类属性的补给

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

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

#
对象在不描述在此之前什么都不是。
#
对象正是内需描述它的动作和特点,手艺去定义它。举例:人,长什么,能做哪些;灯泡,是怎样,能做什么样。

目的的连锁文化

#
类是聊以自慰的,唯有属性和艺术。 dog()函数正是
#
但对象是由此动作和特色的定义的。d一 定义后,正是一条狗了
# 那正是面向对象设计

对象是有关类而实在存在的2个例子,即实例

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

对象/实例唯有1种意义:属性引用

威尼斯人线上娱乐 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)

人狗战争

也足以引用一个方法,因为方法也是三个性格,只然则是二个近似函数的属性,大家也管它叫动态属性。
引用动态属性并不是实行那么些办法,要想调用方法和调用函数是平等的,都亟待在末端加上括号

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

创造1个类(狗类)

 在python个中,没有供给您确定要写面向对象的代码。用面向对象的语言,和三个先后的宏图是面对对象的,两者无任何关系。

实例化一头实实在在的狗

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) #打印圆面积和周长

简短示例协助通晓面向对象

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

创建八个类就会创立3个类的名号空间,用来存款和储蓄类中定义的有着名字,这一个名字称为类的品质

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

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

里头类的多少属性是共享给持有目的的

>>>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种方法,即:组合

重组指的是,在二个类中以其它二个类的靶子作为数据属性,称为类的构成

威尼斯人线上娱乐 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来使用组合类中的所有方法

构成示例

圆环是由三个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上国海洋大学表圆的周长。
本条时候,大家就率先完结三个圆形类,总括3个圆的周长和面积。然后在”环形类”中结合圆形的实例作为团结的属性来用

威尼斯人线上娱乐 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不敌狡猾的人类用武器取胜,血槽空了一半

玩耍小例

根据那种思路一点一点的设计类和对象,最终完全可以兑现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'>,)

接二连三与虚无(先抽象再持续)

架空即收取类似可能说比较像的片段。

泛泛分成五个档期的顺序: 

一.将前美利坚合众国总统和Messi那俩对象比较像的有个别抽出成类; 

贰.将人,猪,狗这三个类相比较像的片段抽出成父类。

架空最重视的机能是分开体系(能够凝集关切点,下降复杂度)

威尼斯人线上娱乐 25

承继:是依照抽象的结果,通过编制程序语言去贯彻它,料定是先经历抽象这么些进程,本事透过一连的点子去发表出抽象的布局。

空洞只是分析和陈设的进程中,1个动作只怕说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()

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

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

采用持续来消除代码重用的事例

在支付顺序的进程中,借使大家定义了1个类A,然后又想新确立其它2个类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方法.

威尼斯人线上娱乐 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)   #执行会报错

接口初成:手动报这1个:NotImplementedError来消除开采中遇见的标题

class Payment:
    def pay(self):
        raise NotImplementedError

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


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

借用abc模块来完毕接口

from abc import ABCMeta,abstractmethod

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


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

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

施行中,承继的首先种意义意义并不异常的大,乃至不时是损伤的。因为它使得子类与基类现身强耦合。

持续的第三种意义极度重大。它又叫“接口承继”。
威尼斯人线上娱乐,接口承继实质上是讲求“做出三个好好的画饼充饥,这一个抽象规定了八个匹配接口,使得外部调用者无需关心具体细节,可并排的管理落成了特定接口的全部目标”——这在先后设计上,叫做归一化。

归壹化使得高层的表面使用者能够不加区分的拍卖全数接口包容的靶子会集——就好象linux的泛文件概念同样,全体东西都能够当文件处理,不必关切它是内部存款和储蓄器、磁盘、网络可能显示屏(当然,对底层设计者,当然也足以区分出“字符设备”和“块设备”,然后做出针对性的希图:细致到哪些水平,视需要而定)。

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

在python中根本就从未有过2个号称interface的最主要字,下面的代码只是看起来像接口,其实并从未起到接口的职能,子类完全能够不用去完结接口 ,假设非要去模仿接口的概念,能够信赖第二方模块:

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

文档

设计形式:

威尼斯人线上娱乐 31威尼斯人线上娱乐 32

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

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

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

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

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

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

缘何要用接口

抽象类

什么是抽象类

*   
与java一样,python也有抽象类的定义但是一样必要借助模块落成,抽象类是二个出奇的类,它的奇怪之处在于只好被持续,无法被实例化*

缘何要有抽象类

   
如果说类是从一堆对象中收取同样的剧情而来的,那么抽象类是从一堆中收取同样的内容而来的,内容包蕴数据属性和函数属性。

* 
比方大家有金蕉的类,有苹果的类,有桃子的类,从那几个类抽出同样的剧情就是鲜果那几个抽象的类,你吃水果时,要么是吃三个实际的天宝蕉,要么是吃几个现实的白桃。。。。。。你永久不能够吃到1个称为水果的事物。*

*   
从布署性角度去看,即使类是从现实对象抽象而来的,那么抽象类便是依据类华而不实而来的。*

* 
从落到实处角度来看,抽象类与普通类的不一致之处在于:抽象类中有抽象方法,该类无法被实例化,只可以被持续,且子类必须贯彻抽象方法。这点与接口有点类似,但实则是不一样的,将要公布答案*

在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),而接口只重申函数属性的相似性。

抽象类是叁个在乎类和接口直接的2个定义,同时具有类和接口的有个别特性,能够用来达成归1化设计 

在python中,并从未接口类那种东西,即使不经过专门的模块定义接口,大家也应该有部分主导的概念。

1.多接二连三难点

在此起彼伏抽象类的进程中,大家应当尽量防止多三番五遍;
而在继续接口的时候,大家反而鼓励你来多一连接口

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

贰.方式的兑现

在抽象类中,大家得以对一些华而不实方法做出基础实现;
而在接口类中,任何方式都只是1种标准,具体的坚守供给子类实现

钻石承袭

承接顺序

威尼斯人线上娱乐 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列表的组织是透过三个C3线性化算法来达成的。大家不去追究这些算法的数学原理,它事实上就是统壹全体父类的MRO列表并依据如下三条规则:
1.子类会先于父类被检查
二.七个父类会依据它们在列表中的顺序被检查
三.假设对下三个类存在七个合法的挑叁拣肆,选拔第三个父类

承接小结

持续的意义

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

多少个名词

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

抽象类与接口类

威尼斯人线上娱乐 38

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


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

威尼斯人线上娱乐 39

钻石承接

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

多态

多态

多态指的是1类东西有种种形态

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

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

多态性

一 什么是多态动态绑定(在后续的背景下使用时,有时也称为多态性)

多态性是指在不挂念实例类型的动静下使用实例

#在面向对象方法中一般是这样表述多态性:
#向不同的对象发送同一条消息(!!!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个外观和表现像,但与它无其余涉及的斩新对象,后者平常用于保存程序组件的松耦合度。

例1:利用标准库中定义的各个‘与公事类似’的对象,纵然这一个目的的职业章程像文件,但她俩一贯不承接内置文件对象的法子

例二:体系类型有种种模样:字符串,列表,元组,但他们直接未有一贯的承接关系

威尼斯人线上娱乐 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. 拉长安全性;

【封装原则】

      一. 将不供给对外提供的故事情节都躲藏起来;

      2. 把品质都藏匿,提供公共艺术对其访问。

民用变量和民用方法

在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,**引用的正是变形的结果**。

二.这种变形其实就是本着外部的变形,在外表是无法通过__x这一个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变产生了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线起始的质量在后续给子类时,子类是无力回天掩盖的。**

 

那种变形须求专注的标题是:

一.那种体制也并不曾真正意义上限定大家从外表直接待上访问属性,知道了类名和属性名就能够拼有名字:_类名__天性,然后就足以访问了,如a._A__N

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

威尼斯人线上娱乐 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

打包与扩充性

封装在于明显区分内外,使得类完毕者能够修改封装内的东西而不影响外部调用者的代码;而外部使用用者只了然三个接口(函数),只要接口(函数)名、参数不改变,使用者的代码永世无需改动。这就提供1个完美的搭档基础——或然说,只要接口这些基础约定不改变,则代码改换不足为虑。

#类的设计者
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
'''

例2:圆的周长和面积

为啥要用property

将三个类的函数定义成特征将来,对象再去采纳的时候obj.name,根本不可能察觉本身的name是实行了3个函数然后总计出来的,那种天性的施用情势安分守纪了联合访问的标准

除了,看下

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

1个静态属性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.面向对象分析(object oriented analysis ,OOA)

   
软件工程中的系统分析阶段,须要分析员和用户结成在一同,对用户的必要做出确切的辨析和明明的表明,从大的地点剖析软件系统应该做哪些,而不是怎么去做。面向对象的解析要遵照面向对象的概念和章程,在对职分的分析中,从客观存在的东西和东西之间的关联,贵南出有关的目的(对象的‘特征’和‘技艺’)以及对象之间的联系,并将有着一样属性和行为的对象用三个类class来标志。

    建立四个能反映那是做事状态的供给模型,此时的模型是简单的。

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

    依据面向对象分析阶段产生的须要模型,对每一片段各自开始展览具体的陈设。

   
首先是类的设计,类的设计只怕包蕴八个等级次序(利用三番五次与派生机制)。然后以那些类为基础建议程序设计的笔触和章程,包含对算法的希图。

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

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

    依据面向对象设计的结果,采取一种Computer语言把它写成程序,能够是python

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

   
在写好程序后交由用户采纳前,必须对先后举办严苛的测试,测试的目标是意识先后中的错误并勘误它。

    面向对的测试是用面向对象的格局开始展览测试,以类作为测试的大旨单元。

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

   
正如对此外产品都供给开展览贩卖后服务和保证同样,软件在行使时也会见世有的难题,可能软件商想革新软件的习性,那就需求修改程序。

    由于采取了面向对象的法子开辟顺序,使用程序的维护相比便于。

   
因为对象的封装性,修改三个目的对别的的目的影响异常的小,利用面向对象的措施维护程序,大大升高了软件维护的作用,可扩充性高。

 

   
在面向对象方法中,最早发展的终将是面向对象编制程序(OOP),那时OOA和OOD都还未有提升起来,由此先后设计者为了写出面向对象的程序,还必须浓厚到剖析和统一盘算领域,特别是统一筹算领域,那时的OOP实际上包括了明天的OOD和OOP四个阶段,那对先后设计者须求相比高,许几个人感觉很难调控。

   
未来计划三个大的软件,是严酷依据面向对象软件工程的四个阶段进行的,这些多少个阶段的办事不是由壹人从头到尾落成的,而是由分裂的人分别成功,那样OOP阶段的职责就相比轻巧了。程序编写者只供给基于OOd提议的思路,用面向对象语言编写出程序既可。

    在一个大型软件开拓进程中,OOP只是比极小的贰个有的。

   
对于全栈开拓的你的话,这五个级次都有了,对于简易的难点,不必严谨遵照那么些6个品级举行,往往由程序设计者遵照面向对象的办法开始展览程序设计,包含类的安排和顺序的安插

 

多少个概念的印证

 

一.面向对象的程序设计看起来高大上,所以笔者在编制程序时就活该保险通篇class,那样写出的先后一定是好的主次(面向对象只适合那多少个可扩充性须求相比高的景色)

2.浩大人喜欢说面向对象三大特征(那是从哪传出来的,封装,多态,承继?漏洞太多太多,好吧权且称为叁大特色),那么自个儿在依据面向对象编制程序时,作者必然要让作者定义的类中完全的涵盖那三种性格,那样写一定是好的主次

好东西,作者说降龙10八掌有拾捌掌,那么您每回跟人干仗都要从第一掌打到第一8掌这才显示你会了是么:面对仇人,你打到第一掌对方就早已倒下了,你说,不行,你给老子起来,老子还平昔不show完…

三.类有类本性,实例有实例属性,所以我们在定义class时必然要定义出那么多少个类属性,想不到咋办,那就努力的想,定义的更多越牛逼

这就犯了一个严重的荒唐,程序越早面向对象,死的越早,为什么面向对象,因为大家要将数据与效益整合到一起,程序全部的结构都并未出来,或然说要求考虑的主题素材你都未有搞精晓个8九不离十,你就起来面向对象了,这就招致了,你在那边干想,自以为想通了,定义了一批属性,结果后来又都用不到,可能想不通到底应该定义啥,那就径直想啊,想着想着就疯了。

你见过哪家市廛要支付2个软件,上来就起来写,料定是频仍的开会研究布置,请看第十节。

面向对象常用术语

抽象/实现

空泛指对切实世界难题和实业的本色表现,行为和特色建立模型,建立几个相关的子集,能够用于
绘程序结构,从而实现那种模型。抽象不仅囊括那种模型的数量属性,还定义了那一个数量的接口。

对某种抽象的得以达成正是对此数据及与之生死相依毛将焉附接口的现实化(realization)。现实化那些进度对于客户
程序应当是晶莹而且非亲非故的。 

封装/接口

包装描述了对数据/音讯举行隐蔽的价值观,它对数码属性提供接口和走访函数。通过任何客户端直接对数码的走访,无视接口,与封装性都是违背的,除非程序员允许那个操作。作为贯彻的
1部分,客户端根本就不必要精通在包装之后,数据属性是如何组织的。在Python中,全部的类属性都以公然的,但名字大概被“混淆”了,以堵住未经授权的访问,但仅此而已,再未有别的堤防措施了。那就要求在准备时,对数据提供相应的接口,防止客户程序通过不标准的操作来存取封装的数据属性。

专注:封装绝不是相等“把不想令人家见到、今后恐怕修改的事物用private隐藏起来”

的确的卷入是,经过浓密的思维,做出美观的虚幻,给出“完整且最小”的接口,并使得内部细节可以对外透明

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

合成

合成扩张了对类的
述,使得七个不等的类合成为一个大的类,来缓慢解决具体主题素材。合成 述了
二个非凡复杂的体系,比如三个类由其他类组成,越来越小的机件也或者是别的的类,数据属性及表现,
全体这么些合在一同,相互是“有二个”的关系。

派生/承袭/继承结构

派生描述了子类衍生出新的风味,新类保留已存类类型中存有要求的多寡和行事,但允许修改大概其它的自定义操作,都不会修改原类的定义。
接轨描述了子类属性从祖先类承接那样一种方法
一连结构意味着多“代”派生,能够述成3个“族谱”,一而再的子类,与祖先类都有提到。

泛化/特化

基于承继
泛化表示具备子类与其父类及祖先类有雷同的性状。
特化描述全体子类的自定义,约等于,什么性质让它与其祖先类分化。

多态与多态性

多态指的是一样种东西的各个景观:水那种事物有多样分裂的情景:冰,水蒸气

多态性的定义提出了对象怎样通过她们合伙的属性和动作来操作及走访,而不需思考他们实际的类。

冰,水蒸气,都承继于水,它们都有2个同名的方法就是形成云,可是冰.变云(),与水蒸气.变云()是完全不一样的进度,即使调用的办法都一样

自省/反射

自省也称作反射,那性格格展示了某目的是怎么着在运维期获得本身新闻的。若是传几个目的给您,你能够查出它有啥样技术,那是一项庞大的特性。假若Python不扶助某种形式的自省效用,dir和type内建函数,将很难平常干活。还有那么些特殊性质,像__dict__,__name__及__doc__


相关文章

发表评论

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

网站地图xml地图