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

By admin in 4858.com on 2019年4月6日

透过多少个函数式编号演进,领会面向对象设计

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 ,

# 那么三个函数,
# 正是给定分化性质,设置属性到它里面,
# 并且它里面包车型客车函数使用了那么些属性,实现了新的动作,
#
通过重临方法至三个字典当中,让外部调用那些措施(属性和措施都亟需让外部去拜谒,在字典类型当中来讲,是均等的),
# 即完毕了所谓的【面向对象】

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

# 类是空泛的,唯有属性和办法。 dog()函数便是
# 但对象是通过动作和特征的概念的。d壹 定义后,正是一条狗了
# 那正是面向对象设计

 

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

面向进度 VS 面向对象

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

亮点是:相当的大的减退了写程序的复杂度,只必要顺着要推行的步调,堆叠代码即可。

缺陷是:一套流水生产线也许流程正是用来缓解3个难点,代码牵一发而动全身。

运用场景:一旦形成基本很少改变的处境,盛名的事例有Linux內核,git,以及Apache
HTTP Server等。

 

面向对象的次第设计的骨干是目标(上帝式思维),要精晓对象为啥物,必须把团结真是上帝,上帝眼里世间存在的万物皆为指标,不设有的也足以创立出来。面向对象的次序设计好比世尊布置西游记,世尊要消除的标题是把经书传给东土大唐,释迦牟尼佛想了想消除这么些难题亟待四人:唐三藏,金身罗汉,猪8戒,孙猴子,每一个人都有分其他风味和技术(那就是指标的概念,特征和技能分别对应对象的品质和方法),但是那并倒霉玩,于是释迦牟尼佛又布置了一堆妖妖怪怪,为了防范师傅和徒弟多少人在取经路上被搞死,又布置了一堆神明保驾保护航行,这几个都以指标。然后取经开始,师傅和徒弟多少人与妖魔鬼怪神明相互缠斗着直到最后收获真经。如来根本不会管师傅和徒弟三个人遵照什么流程去取。

面向对象的主次设计的

python面向对象设计,初识面向对象。亮点是:解决了先后的扩张性。对某1个目的单独修改,会即时反映到整个系统中,如对娱乐中1个人选参数的天性和技艺修改都很简单。

缺陷:可控性差,不可能向面向进度的先后设计流水生产线式的能够很精准的臆度难点的拍卖流程与结果,面向对象的次序壹旦初步就由对象之间的互相化解难点正是是上帝也无力回天预测最后结果。于是大家平日来看二个游乐人某1参数的修改极有希望造成阴霸的技巧出现,一刀砍死三位,这几个游戏就失去平衡。

选择场景:供给常常变化的软件,1般要求的变通都集聚在用户层,互连网使用,公司中间软件,游戏等都以面向对象的主次设计大显身手的好地点。

在python 中面向对象的程序设计并不是百分百。

面向对象编制程序能够使程序的掩护和扩充变得更简约,并且能够大大进步程序支付作用,别的,基于面向对象的顺序能够使它人进一步便于理解你的代码逻辑,从而使集体开支变得更从容。

询问部分名词:类、对象、实例、实例化

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

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

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

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

Python 面向对象之 类与品质

   
明天接触了一下边向对象,发现面向对象和前边知道的简直就是天壤之别,在学Linux的时候,1切皆文件,今后学面向对象了,so,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
五个函数,还定义了多个字典,在那个字典中吗有定义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这个狗


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

这一遍是在事先的底子上把再次来到值做成3个init的函数通过那一个函数来推行字典里面包车型客车剧情,假使要调用定义def
dog中的方法,调用格局为:d1[‘jiao’](d1)
#调用字典的值加括号进行运此函数。

是否如故面向函数完成了把dog
的质量和方法封装在函数中贯彻了,好了接下去用面向对象来兑现上述的职能:

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

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

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

好以后计算一下,类:正是把一类东西的同样特征和动作结合在壹道就是类,类正是2个抽象概念。对象:正是依据类成立的八个有血有肉的事物(具体存在的),也是把动作和特点结合在1块儿。

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

获得类属性和实例化的品质举例:

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

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


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

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

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

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

 

面向对象之一,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’}这几个字典,它是一个字典,能够选择字典的持有办法,并且在那之中有了切实可行的值,它正是字典的三个指标。对象就是早就确实存在的某一个有血有肉的村办。

 

再举叁个任何的事例,通俗一点,比如你今后有三个动物园,你想描述这一个动物园,那么动物园里的每壹种动物正是三个类,老虎、天鹅、鳄鱼、熊。他们都有平等的性质,比如身高体重出生时间和档次,还有种种动作,比如鳄鱼会游泳,天鹅会飞,老虎会跑,熊会吃。

只是那些老虎熊啥的都不是切实的某一只,而是1类动物。尽管她们都有身高体重,但是你却尚无办法规定这么些值是有点。要是那一年给您一只具体的大虫,而你还没死,这你就能给她量量身高称称体重,那几个数值是否就成为实际的了?那么具体的那1只猛虎正是二个现实的实例,也是2个目的。不止那1只,其实每一只具体的大虫都有本人的身高体重,那么每贰只老虎都是老虎类的二个对象。

在python中,用变量表示特征,用函数表示技术,由此具有同等特征和技艺的一类东西正是‘类’,对象是则是那一类东西中现实的二个。

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

类的有关知识

 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__函数的运维,能够用它来为每种实例定制本人的性状

4858.com 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)  #引用人的走路方法,注意,这里不是在调用

4858.com 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__的第一个参数,也足以起各自的名字,但是1般不会那样做,大家墨守成规为self,修改之后不便于分辨。

# 那么叁个函数,
#
便是给定差异性质,设置属性到它在这之中,
#
并且它里面包车型地铁函数使用了那几个属性,完毕了新的动作,
#
通过再次来到方法至1个字典在那之中,让外部调用那些方法(属性和措施都亟需让外部去拜访,在字典类型在那之中来讲,是如出一辙的),
#4858.com,
即实现了所谓的【面向对象】

类属性的补充

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

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

#
对象在不描述此前什么都不是。
#
对象正是必要描述它的动作和特点,才能去定义它。比如:人,长什么,能做哪些;灯泡,是何许,能做什么样。

对象的相关文化

#
类是空虚的,唯有属性和措施。 dog()函数正是
#
但对象是透过动作和特色的概念的。d一 定义后,正是一条狗了
# 这就是面向对象设计

指标是关于类而其实存在的2个事例,即实例

类就像是模板,定义后正是1个指标了。

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

4858.com 34858.com 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)

人狗大战

也得以引用四个艺术,因为方法也是2本性能,只可是是三个看似函数的属性,我们也管它叫动态属性。
引用动态属性并不是实施那一个主意,要想调用方法和调用函数是一致的,都亟需在背后加上括号

print(egg.attack)

自家精晓在类里说,你恐怕还有不少地方不能够知晓。这我们就用函数来解释一下那个类呀,对象啊到底是个什么,你悄悄的用那几个驾驭就好了,不要告诉外人

4858.com 54858.com 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'])

接济了然面向对象

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

4858.com 74858.com 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   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

小结

4858.com 94858.com 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()

习题


类—–发生—–对象的长河叫压实例化(实例=对象)

目的之间的相互

人狗大战之血腥互搏

4858.com 114858.com 12

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

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

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

创建二个类(狗类)

 在python其中,未有须求你一定要写面向对象的代码。用面向对象的言语,和多少个程序的统一筹划是面对对象的,两者无其余涉及。

实例化三头实实在在的狗

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

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

交互 egon打ha2一下

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

 

完全的代码

4858.com 134858.com 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点血

人狗互搏之孰生孰死

4858.com 154858.com 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个类就会成立2个类的称谓空间,用来存款和储蓄类中定义的具备名字,那么些名字称为类的性子

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

  • 静态属性便是一直在类中定义的变量
  • 动态属性正是概念在类中的方法

在那之中类的数目属性是共享给持有指标的

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

组成指的是,在1个类中以别的多少个类的靶子作为数据属性,称为类的组成

4858.com 174858.com 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来使用组合类中的所有方法

重组示例

圆环是由多个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是在那之中圆的周长加上海外国语大学表圆的周长。
其暂且候,大家就率先落到实处五个圆形类,总括一个圆的周长和面积。然后在”环形类”中结成圆形的实例作为本人的性子来用

4858.com 194858.com 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()) #计算环形的面积

测算圆环的面积和周长

用整合的点子确立了类与整合的类之间的关系,它是1种‘有’的涉嫌,比如教授有寿辰,教师教python课程

4858.com 214858.com 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

当类之间有令人惊叹区别,并且较小的类是较大的类所须要的机件时,用结合相比好

初识面向对象小结

4858.com 234858.com 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个周到的对战类游戏。

面向对象的叁大特征

继承

什么样是三番7次

接二连三是1种创造新类的点子,在python中,新建的类能够继续1个或四个父类,父类又可称之为基类或超类,新建的类称为派生类或子类

 

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那俩对象相比较像的部分抽取成类; 

二.将人,猪,狗那四个类比较像的片段抽取成父类。

空泛最关键的机能是分开体系(能够凝集关心点,降低复杂度)

4858.com 25

继承:是依照抽象的结果,通过编制程序语言去落到实处它,肯定是先经历抽象那个进程,才能经过持续的诀要去表述出抽象的组织。

架空只是分析和筹划的历程中,二个动作大概说一种技术,通过架空能够博得类

4858.com 26

持续与重用性

4858.com 274858.com 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,然后又想新确立其它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参数也要为其传值.

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

4858.com 294858.com 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

抽象类与接口类

接口类

接轨有二种用途:

一:继承基类的法子,并且做出自个儿的更动或许扩大(代码重用)  

二:注明有个别子类包容于某基类,定义贰个接口类Interface,接口类中定义了一些接口名(就是函数名)且未有完毕接口的功效,子类继承接口类,并且完结接口中的功用

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

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


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


p = Alipay()
pay(p,200)

支付中易于出现的题材

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

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

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

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


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

接口初成:手动报那些:NotImplementedError来缓解开发中遭受的题材

class Payment:
    def pay(self):
        raise NotImplementedError

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


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

借用abc模块来促成接口

from abc import ABCMeta,abstractmethod

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


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

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

推行中,继承的第一种意义意义并不十分的大,甚至经常是风险的。因为它使得子类与基类出现强耦合。

一而再的第二种意义卓殊重大。它又叫“接口继承”。
接口继承实质上是讲求“做出一个非凡的用空想来欺骗别人,那么些抽象规定了二个相称接口,使得外部调用者无需关切具体细节,可并排的拍卖落成了特定接口的具备指标”——那在先后设计上,叫做归一化。

归一化使得高层的外部使用者能够不加区分的拍卖全体接口包容的对象集合——就好象linux的泛文件概念壹样,全部东西都得以当文件处理,不必关怀它是内部存款和储蓄器、磁盘、互联网或许荧屏(当然,对底层设计者,当然也能够区分出“字符设备”和“块设备”,然后做出针对性的筹划:细致到何等水平,视必要而定)。

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

在python中平素就从不一个叫做interface的重点字,上边包车型客车代码只是看起来像接口,其实并不曾起到接口的功效,子类完全能够不用去完成接口 ,要是非要去模仿接口的定义,能够借助第二方模块:

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

文档

设计情势:

4858.com 314858.com 32

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

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

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

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

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

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

缘何要用接口

抽象类

怎么着是抽象类

*   
与java1样,python也有抽象类的概念可是同样须求重视模块实现,抽象类是3个格外的类,它的很是之处在于只可以被持续,无法被实例化*

何以要有抽象类

   
如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类是从一堆中抽取相同的始末而来的,内容囊括数据属性和函数属性。

* 
比如大家有香蕉的类,有苹果的类,有桃子的类,从那几个类抽取相同的内容便是水果这一个抽象的类,你吃水果时,要么是吃二个切实可行的香蕉,要么是吃二个实际的桃子。。。。。。你永远无法吃到二个名字为水果的东西。*

*   
从设计角度去看,倘使类是从现实对象抽象而来的,那么抽象类正是依照类华而不实而来的。*

* 
从贯彻角度来看,抽象类与普通类的不相同之处在于:抽象类中有抽象方法,该类不可能被实例化,只好被延续,且子类必须兑现抽象方法。那或多或少与接口有点类似,但骨子里是例外的,即将公布答案*

在python中落到实处抽象类

4858.com 334858.com 34

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

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

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

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

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

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

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

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

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

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

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

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

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

View Code

抽象类与接口类

抽象类的真相还是类,指的是一组类的相似性,包涵数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

抽象类是一个在于类和接口直接的二个定义,同时具备类和接口的一部分性格,能够用来促成归壹化设计 

在python中,并未接口类这种东西,固然不通过专门的模块定义接口,大家也应有有一些骨干的概念。

1.多继承难点

在此起彼伏抽象类的长河中,我们应有尽量制止多接二连三;
而在继续接口的时候,大家反而鼓励你来多三番伍回接口

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

二.艺术的贯彻

在抽象类中,大家能够对有的抽象方法做出基础实现;
而在接口类中,任何方法都只是一种标准,具体的职能须要子类完成

钻石继承

继续顺序

4858.com 35

 

4858.com 364858.com 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三线性化算法来落到实处的。大家不去探索那个算法的数学原理,它实际上正是统1全数父类的MRO列表并依据如下三条轨道:
一.子类会先于父类被检查
二.八个父类会依据它们在列表中的顺序被检查
3.比方对下1个类存在八个法定的精选,选用第二个父类

接轨小结

继续的效劳

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

多少个名词

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

抽象类与接口类

4858.com 38

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


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

4858.com 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程序员经常依照那种行为来编写程序。例如,假若想编写现有对象的自定义版本,能够一而再该指标

也足以创建三个外观和行事像,但与它无别的涉及的全新对象,后者平日用于保存程序组件的松耦合度。

例一:利用标准库中定义的各样‘与公事类似’的靶子,就算这个指标的办事措施像文件,但他俩未尝继承内置文件对象的不二等秘书籍

例二:种类类型有各样形态:字符串,列表,元组,但她俩直白没有一贯的后续关系

4858.com 404858.com 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. 增加安全性;

【封装原则】

      1. 将不需求对外提供的内容都掩藏起来;

      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,即双下滑线开始的属性在再而三给子类时,子类是无力回天覆盖的。**

 

那种变形需求注意的难点是:

1.那种机制也并从未真的含义上限定我们从表面直接访问属性,知道了类名和属性名就足以拼著名字:_类名__脾性,然后就能够访问了,如a._A__N

二.变形的经过只在类的内部生效,在概念后的赋值操作,不会变形

4858.com 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

打包与扩张性

封装在于明确区分内外,使得类达成者可以修改封装内的事物而不影响外部调用者的代码;而外部使用用者只略知一贰2个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需变更。这就提供2个大好的同盟基础——可能说,只要接口这些基础约定不变,则代码改变不足为虑。

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


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


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


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

property属性

怎么样是特色property

property是1种独特的品质,访问它时会执行壹段作用(函数)然后再次来到值

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

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

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

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

4858.com 434858.com 44

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

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

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

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


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

例2:圆的周长和面积

为何要用property

将二个类的函数定义成特征今后,对象再去选用的时候obj.name,根本不可能察觉本人的name是实践了八个函数然后总结出来的,那种特征的行使方法依据了合并访问的标准

除此而外,看下

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

python并从未在语法上把它们四个内建到自个儿的class机制中,在C++里1般会将具有的享有的数额都设置为个人的,然后提供set和get方法(接口)去设置和获得,在python中通过property方法能够兑现

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

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

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

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

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

三个静态属性property本质就是兑现了get,set,delete二种格局

4858.com 454858.com 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

4858.com 474858.com 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机制之后,遇到1个生产中的难题,还是会懵逼,那实在太平常了,因为其余程序的支出都以先规划后编程,python的class机制只但是是一种编制程序方式,要是您硬要拿着class去和您的题材死磕,变得特别懵逼都以分分钟的事,在原先,软件的花费相对简便易行,从职务的剖析到编写程序,再到程序的调剂,能够由一位或三个小组去做到。但是随着软件规模的飞快增大,软件任意面临的题材13分复杂,须求考虑的因素太多,在七个软件中所产生的荒谬和隐藏的一无所能、未知的一无可取大概高达惊人的程度,那也不是在设计阶段就完全缓解的。

   
所以软件的支出其实一整套正式,大家所学的只是在那之中的一小部分,叁个完全的开发进度,要求明显每一个阶段的天职,在担保二个阶段正确的前提下再拓展下二个等级的工作,称之为软件工程

    面向对象的软件工程包涵上边几个部:

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

   
软件工程中的系统一分配析阶段,须求分析员和用户结成在同步,对用户的须求做出确切的剖析和显眼的发挥,从大的方面剖析软件系统应该做怎么着,而不是怎么去做。面向对象的辨析要依据面向对象的概念和方式,在对义务的剖析中,从客观存在的事物和东西之间的涉嫌,贵南出有关的指标(对象的‘特征’和‘技能’)以及对象时期的调换,并将全数相同属性和行事的目的用一个类class来标识。

    建立一个能显示那是干活情景的急需模型,此时的模子是大约的。

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

    根据面向对象分析阶段形成的必要模型,对每壹有的各自开始展览实际的设计。

   
首先是类的筹划,类的筹划或者包涵两个层次(利用接二连三与派生机制)。然后以那几个类为基础建议程序设计的笔触和格局,蕴含对算法的宏图。

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

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

    依据面向对象设计的结果,选取壹种总括机语言把它写成程序,能够是python

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

   
在写好程序后提交用户使用前,必须对程序进行严酷的测试,测试的目标是意识先后中的错误并修正它。

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

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

   
正如对此外产品都必要开始展览售后服务和掩护壹样,软件在行使时也会冒出局地难点,或许软件商想改进软件的质量,那就须要修改程序。

    由于选用了面向对象的主意开发顺序,使用程序的护卫比较便于。

   
因为对象的封装性,修改2个对象对其余的对象影响相当小,利用面向对象的格局维护程序,大大升高了软件维护的成效,可增加性高。

 

   
在面向对象方法中,最早发展的必然是面向对象编制程序(OOP),那时OOA和OOD都还未曾升高起来,由此先后设计者为了写出面向对象的先后,还非得深入到剖析和布置性领域,尤其是安插领域,那时的OOP实际上包蕴了当今的OOD和OOP三个级次,那对先后设计者供给相比高,许多个人倍感很难精晓。

   
今后布署3个大的软件,是严刻根据面向对象软件工程的多少个级次进行的,那个5个阶段的干活不是由一人从头到尾完结的,而是由不一致的人分头完结,那样OOP阶段的天职就比较不难了。程序编写者只要求基于OOd提议的笔触,用面向对象语言编写出程序既可。

    在一个大型软件开发进程中,OOP只是非常的小的一个片段。

   
对于全栈开发的您来说,那八个等级都有了,对于简易的题材,不必严厉根据那么些五个级次举办,往往由程序设计者遵照面向对象的点子开始展览程序设计,包括类的规划和次序的统一筹划

 

多少个概念的验证

 

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

二.众多少人喜欢说面向对象3大特点(这是从哪传出来的,封装,多态,继承?漏洞太多太多,好吧一时称为3大特征),那么作者在依据面向对象编制程序时,笔者决然要让自个儿定义的类中总体的带有那两种特色,那样写一定是好的次序

好东西,我说降龙拾八掌有108掌,那么你每一趟跟人干仗都要从第贰掌打到第三8掌这才显得你会了是么:面对仇敌,你打到第三掌对方就早已倒下了,你说,不行,你给老子起来,老子还尚无show完…

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

那就犯了三个严重的荒谬,程序越早面向对象,死的越早,为什么面向对象,因为大家要将数据与功效结合到手拉手,程序全部的布局都未有出去,恐怕说需求思考的标题你都未曾搞理解个捌九不离10,你就从头面向对象了,那就造成了,你在这里干想,自以为想通了,定义了一群属性,结果后来又都用不到,可能想不通到底应该定义啥,那就一贯想呢,想着想着就疯了。

您见过哪家公司要付出多少个软件,上来就从头写,肯定是几度的开会琢磨安顿,请看第八节。

面向对象常用术语

抽象/实现

泛泛指对现实世界难题和实体的真相表现,行为和个性建立模型,建立二个皮之不存毛将焉附的子集,能够用来
绘程序结构,从而完毕这种模型。抽象不仅包含那种模型的数码属性,还定义了这几个多少的接口。

对某种抽象的贯彻就是对此数量及与之相关接口的现实化(realization)。现实化那个进度对于客户
程序应当是晶莹剔透而且无关的。 

封装/接口

包装描述了对数码/音信举办隐蔽的守旧,它对数据属性提供接口和做客函数。通过别的客户端直接对数码的访问,无视接口,与封装性都是违反的,除非程序员允许那么些操作。作为落到实处的
一部分,客户端根本就不必要知道在卷入之后,数据属性是哪些社团的。在Python中,全体的类属性都以堂而皇之的,但名字也许被“混淆”了,以阻挠未经授权的拜访,但仅此而已,再未有别的预防措施了。那就要求在规划时,对数码提供对应的接口,避防客户程序通过不标准的操作来存取封装的数目属性。

瞩目:封装绝不是非常“把不想让旁人看到、未来可能修改的东西用private隐藏起来”

真正的包裹是,经过深切的构思,做出优良的画饼充饥,给出“完整且最小”的接口,并使得内部细节能够对外透明

(注意:对外透明的意趣是外部调用者能够万事大吉的拿走协调想要的其他功效,全盘意识不到里头细节的留存)

合成

合成扩充了对类的
述,使得三个例外的类合成为四个大的类,来化解实际难点。合成 述了
3个卓殊复杂的系统,比如3个类由其余类组成,更小的零部件也说不定是别的的类,数据属性及行为,
全部这个合在一起,互相是“有四个”的关联。

派生/继承/继承结构

派生描述了子类衍生出新的性状,新类保留已存类类型中持有要求的数量和作为,但允许修改大概别的的自定义操作,都不会修改原类的概念。
后续描述了子类属性从祖先类继承那样1种形式
一而再结构意味着多“代”派生,能够述成三个“族谱”,三番五次的子类,与祖先类都有涉及。

泛化/特化

依据继承
泛化表示全体子类与其父类及祖先类有相同的特点。
特化描述全部子类的自定义,也便是,什么性质让它与其祖先类分化。

多态与多态性

多态指的是一模1样种东西的有余动静:水这种东西有两种不相同的情事:冰,水蒸气

多态性的概念提出了目的怎样通过他们一起的质量和动作来操作及走访,而不需思虑他们具体的类。

冰,水蒸气,都持续于水,它们都有二个同名的法子就是变成云,然而冰.变云(),与水蒸气.变云()是全然不一致的经过,纵然调用的点子都同壹

自省/反射

扪心自问也称作反射,那么些性情显示了某指标是哪些在运营期取得本身消息的。如若传三个指标给你,你能够识破它有怎么样力量,那是一项强大的风味。假若Python不辅助某种格局的反省作用,dir和type内建函数,将很难平常工作。还有那多少个特殊属性,像__dict__,__name__及__doc__

发表评论

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

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