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

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

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

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

def01.py

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

 def02.py

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

def03.py

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

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

 

def04.py

 6 
 7 def dog(name,gender,type):
 8     def jiao(dog):
 9         print('一条狗[%s],汪汪'%dog['name'])
10 
11     def yaoren(dog):
12         print('一条狗[%s]正在咬人'%dog['type'])
13 
14     def init(name,gender,type):
15         dog1 = {
16             'name': name,
17             'gender': gender,
18             'type': type,
19             'jiao':jiao,#内部函数
20             'yaoren':yaoren#内部函数
21         }
22         return dog1
23 
24     return init(name,gender,type)
25 
26 d1 = dog('张明','母','腊肠')

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

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

# 那么一个函数,
# 正是给定差异属性,设置属性到它在那之中,
# 并且它里面的函数使用了这几个属性,完毕了新的动作,
#
通过重临方法至一个字典个中,让外部调用这些方法(属性和格局都亟需让外部去拜访,在字典类型个中来讲,是同等的),
# 即完结了所谓的【面向对象】

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

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

 

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

面向进度 VS 面向对象

面向进度的次第设计的主导是经过(流水生产线式思维),进度即解决难点的步子,面向进程的安排就好比精心设计好一条流水生产线,思念周详几时管理什么事物。

可取是:相当大的狂跌了写程序的复杂度,只供给顺着要施行的步调,聚积代码就能够。

缺点是:1套流水生产线也许流程正是用来化解八个标题,代码牵一发而动全身。

使用场景:一旦成功基本很少改换的场景,有名的事例有Linux內核,git,以及Apache
HTTP Server等。

 

面向对象的先后设计的主导是目的(上帝式思维),要清楚对象为啥物,必须把温馨正是上帝,上帝眼里世间存在的万物皆为目标,不设有的也得以成立出来。面向对象的程序设计好比世尊安插西游记,如来佛要消除的主题素材是把经书传给东土大唐,世尊想了想化解这一个标题亟需四个人:三藏法师,沙僧,猪八戒,孙猴子,每种人都有分其余表征和技能(那正是目的的概念,特征和本领分别对应对象的属性和章程),但是那并倒霉玩,于是释尊又安顿了一堆妖妖魔怪,为了防范师傅和徒弟多人在取经路上被搞死,又布署了一堆神仙保驾护航,那一个都以目标。然后取经初始,师傅和徒弟几个人与妖鬼怪怪佛祖相互缠斗着直到最后收获真经。释尊根本不会管师傅和徒弟多人根据什么流程去取。

面向对象的程序设计的

优点是:解决了先后的扩大性。对某贰个目标单独修改,会马上反映到一切系统中,如对游戏中壹位物参数的表征和本事修改都很轻便。

症结:可控性差,不也许向面向进程的顺序设计流水生产线式的能够很精准的预测难点的拍卖流程与结果,面向对象的主次壹旦起先就由对象之间的相互化解难题就算是上帝也不能够揣度最后结出。于是大家日常看看一个嬉戏人某一参数的修改极有希望引致阴霸的才干现身,1刀砍死二人,那么些娱乐就失去平衡。

动用场景:须要平日转移的软件,一般须求的变通都集聚在用户层,网络接纳,公司中间软件,游戏等都以面向对象的顺序设计大显身手的好地点。

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

面向对象编制程序能够使程序的维护和增加变得更简便易行,并且能够大大升高程序支付成效,此外,基于面向对象的次第能够使它人特别便于领会你的代码逻辑,从而使集团支付变得更从容。

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

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

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

实例化:类——>对象的进程

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

Python 面向对象之 类与特性

   
前几天触及了瞬间面向对象,发掘面向对象和事先知道的差不多正是相去甚远,在学Linux的时候,一切皆文件,未来学面向对象了,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
八个函数,还定义了1个字典,在那么些字典中呢有定义dog的数额属性,比方:名字,性别等,还有函数属性
叫和就餐,在函数最终有二个回来值return 重返的吧是dog
这几个字典,打印d一的数值就会意识:得到的是1个字典类型的数量,在那之中等高校函授数属性再次来到的是函数的内部存储器地址。

在此基础上开展革新:

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


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

那一次是在在此以前的根基上把重回值做成贰个init的函数通过这一个函数来实践字典里面包车型的士内容,假设要调用定义def
dog中的方法,调用方式为:d一[‘jiao’](d1)
#调用字典的值加括号举行运此函数。

是或不是依旧面向函数落成了把dog
的习性和格局封装在函数中落到实处了,好了接下去用面向对象来贯彻上述的功用:

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

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

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

好未来总计一下,类:正是把①类东西的一样特征和动作结合在联合签名就是类,类就是2个抽象概念。对象:正是基于类创造的多少个具体的东西(具体存在的),也是把动作和特征结合在一道。

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

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

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

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

类属性的增删改查:

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

 

面向对象之一,python面向对象 Python
面向对象之 类与属性
前些天触及了弹指间面向对象,开掘面向对象和事先知道的大概正是一丈差九尺,…

def01.py

初识类和目标

python中全方位皆为目的,类型的精神便是类

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

从上边的例证来看,字典正是1类数据结构,作者壹说字典你就通晓是不行用{}表示,里面由k-v键值对的东西,它还有着部分增加和删除改查的主意。不过本人壹说字典你能分晓字典里具体存了什么内容么?无法,所以大家说对于一个类来讲,它具有一样的表征属性和方法。

而具体的{‘name’:’eva’}那些字典,它是二个字典,能够利用字典的持有办法,并且其中有了现实的值,它正是字典的叁个对象。对象正是早就确实存在的某3个具体的私有。

 

再举1个任何的事例,通俗一点,比方你现在有二个动物园,你想描述那些动物园,那么动物园里的每1种动物正是1个类,老虎、天鹅、鳄鱼、熊。他们都有平等的属性,比方身高体重出生时间和品种,还有种种动作,比方鳄鱼会游泳,天鹅会飞,老虎会跑,熊会吃。

而是那个老虎熊啥的都不是切实可行的某二头,而是一类动物。就算他们都有身高体重,然而你却尚未艺术显著这么些值是有点。假使那个时候给您二只具体的大虫,而你还没死,那你就能给她量量身高称称体重,这几个数值是还是不是就改为现实性的了?那么具体的这四头老虎就是三个实际的实例,也是叁个目标。不止这1只,其实每一只具体的老虎都有友好的身高体重,那么每叁头猛虎都以老虎类的贰个对象。

python面向对象设计,python面向对象。在python中,用变量表示特征,用函数表示本事,由此具备同等特征和才能的1类东西正是‘类’,对象是则是那1类东西中现实的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类,在那几个进度中,发生了1个egg对象,有温馨现实的名字、攻击力和生命值。

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

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

def04.py

查阅属性&调用方法

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

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

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

关于self

self:在实例化时自动将目的/实例本身传给__init__的首先个参数,也得以起各自的名字,但是一般不会如此做,我们固步自封为self,修改今后不便宜识别。

# 那么三个函数,
#
就是给定不相同属性,设置属性到它当中,
#
并且它个中的函数使用了这几个属性,完毕了新的动作,
#
通过重返方法至四个字典个中,让外部调用这一个办法(属性和艺术都急需让外部去做客,在字典类型在那之中来讲,是同样的),
#
即完毕了所谓的【面向对象】

类属性的补偿

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

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

#
对象在不描述在此之前什么都不是。
#
对象正是要求描述它的动作和天性,技能去定义它。举个例子:人,长什么样,能做怎么样;灯泡,是怎么着,能做怎么样。

对象的连锁文化

#
类是虚幻的,只有属性和方式。 dog()函数就是
#
但对象是通过动作和特点的概念的。d一 定义后,正是一条狗了
# 那正是面向对象设计

目的是关于类而实际存在的3个例证,即实例

类就如模板,定义后就是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)

人狗战斗

也能够引用1个办法,因为方法也是四个属性,只但是是二个像样函数的属性,大家也管它叫动态属性。
引用动态属性并不是施行那几个形式,要想调用方法和调用函数是一模同样的,都要求在末端加上括号

print(egg.attack)

自己晓得在类里说,你大概还有多数地点不可能领会。这我们就用函数来解释一下那个类呀,对象啊到底是个什么,你私自的用这几个精晓就好了,不要告诉别人

美高梅开户网址 5美高梅开户网址 6

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

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

    __init__(*args,**kwargs)
    return self

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

帮助精通面向对象

面向对象小结——定义及调用的定位方式

美高梅开户网址 7美高梅开户网址 8

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

    def 方法名(self):pass

    def 方法名2(self):pass

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

小结

美高梅开户网址 9美高梅开户网址 10

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

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

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

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

习题


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

目的之间的互相

人狗战役之血腥互搏

美高梅开户网址 11美高梅开户网址 12

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

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

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

始建一个类(狗类)

 在python在那之中,未有须求你一定要写面向对象的代码。用面向对象的言语,和三个主次的宏图是面对对象的,两者无其余涉及。

实例化三只实实在在的狗

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

您写的次第是还是不是面向对象的,和您用的语言是还是不是面向对象的非亲非故系!面向对象设计,只可是是函数/进程式编制程序的朝3暮4。关键在于面向对象的陈设思路。

交互 egon打ha2一下

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

 

1体化的代码

美高梅开户网址 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> 

创设3个对象/实例就会创立八个对象/实例的称谓空间,存放对象/实例的名字,称为对象/实例的品质

在obj.name会先从obj自个儿的称呼空间里找name,找不到则去类中找,类也找不到就找父类…最后都找不到就抛出格外

 

面向对象的三结合用法

软件重用的严重性措施除了一而再之外还有其余1种艺术,即:组合

重组指的是,在1个类中以此外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来使用组合类中的所有方法

组成示例

圆环是由三个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是里面圆的周长加上国外国语高校表圆的周长。
以此时候,大家就率先得以落成多个圆形类,总结贰个圆的周长和面积。然后在”环形类”中结合圆形的实例作为友好的性质来用

美高梅开户网址 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大特征

继承

何以是延续

继续是1种成立新类的办法,在python中,新建的类能够持续3个或多少个父类,父类又可称之为基类或超类,新建的类称为派生类或子类

 

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

两次三番:是基于抽象的结果,通过编制程序语言去完结它,确定是先经历抽象那几个进度,才具通过接二连三的秘技去表述出抽象的构造。

空泛只是分析和统一准备的历程中,3个动作或然说1种手艺,通过架空能够拿到类

美高梅开户网址 26

此起彼伏与重用性

美高梅开户网址 27美高梅开户网址 28

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

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

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

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


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

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

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗:

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

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something



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

  动物:吃、喝、拉、撒

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

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

伪代码如下:
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

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

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

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

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




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

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

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

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

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


class Cat(Animal):

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

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

class Dog(Animal):

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

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


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

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

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

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

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

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

动用持续来缓慢解决代码重用的事例

在支付顺序的经过中,如果大家定义了二个类A,然后又想新创建其它3个类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

抽象类与接口类

接口类

继续有二种用途:

一:承继基类的点子,并且做出本身的改造可能增加(代码重用)  

二:表明有个别子类包容于某基类,定义3个接口类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)   #执行会报错

接口初成:手动报那2个: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() #不调就报错了

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

此起彼伏的第二种意义万分首要。它又叫“接口承继”。
接口承袭实质上是讲求“做出3个非凡的空洞,那个抽象规定了一个才子佳人接口,使得外部调用者无需关怀具体细节,可并排的拍卖达成了特定接口的富有目标”——那在先后设计上,叫做归1化。

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

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

在python中平素就未有一个叫做interface的首要字,上边的代码只是看起来像接口,其实并从未起到接口的功用,子类完全能够不用去落成接口 ,倘使非要去模仿接口的定义,能够依附第三方模块:

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

文档

设计方式:

美高梅开户网址 31美高梅开户网址 32

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

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

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

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

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

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

为啥要用接口

抽象类

怎么是抽象类

*   
与java同样,python也有抽象类的定义可是一样需求依赖模块实现,抽象类是二个独特的类,它的独特之处在于只可以被延续,不可能被实例化*

干什么要有抽象类

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

* 
比方大家有西贡蕉的类,有苹果的类,有黄肉桃的类,从那个类抽出一样的故事情节正是鲜果那么些抽象的类,你吃水果时,要么是吃2个切实的西贡蕉,要么是吃2个具体的黄肉桃。。。。。。你永久不能够吃到叁个名字为水果的事物。*

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

* 
从得以达成角度来看,抽象类与普通类的差异之处在于:抽象类中有抽象方法,该类不能够被实例化,只好被接续,且子类必须兑现抽象方法。那或多或少与接口有点类似,但事实上是差别的,将在公布答案*

在python中完毕抽象类

美高梅开户网址 33美高梅开户网址 34

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

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

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

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

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

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

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

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

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

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

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

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

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

View Code

抽象类与接口类

抽象类的本质照旧类,指的是一组类的相似性,包罗数据属性(如all_type)和函数属性(如read、write),而接口只重申函数属性的相似性。

抽象类是1个在于类和接口直接的3个概念,同时具有类和接口的一些性情,能够用来贯彻归1化设计 

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

一.多继续难点

在持续抽象类的经过中,大家相应尽量制止多一而再;
而在延续接口的时候,大家反而鼓励你来多三番五次接口

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

二.主意的达成

在抽象类中,我们能够对有些空洞方法做出基础落成;
而在接口类中,任何格局都只是一种标准,具体的机能须求子类实现

钻石承继

三番五次顺序

美高梅开户网址 35

 

美高梅开户网址 36美高梅开户网址 37

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

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

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

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

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

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

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

继承顺序

此起彼伏顺序

持续原理

python到底是哪些完成持续的,对于你定义的每3个类,python会总结出一个主意分析顺序(MRO)列表,那个MRO列表正是二个大约的享有基类的线性顺种类表,比如

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

为了兑现持续,python会在MRO列表上从左到右初步查找基类,直到找到第三个非凡这些性格的类截止。
而以此MRO列表的构造是经过二个C三线性化算法来落到实处的。大家不去追究这么些算法的数学原理,它实际上就是联合全体父类的MRO列表并遵守如下三条规则:
一.子类会先于父类被检查
二.三个父类会遵照它们在列表中的顺序被检查
3.假设对下一个类存在四个合法的采纳,选用首个父类

继承小结

此起彼伏的职能

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

多少个名词

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

抽象类与接口类

美高梅开户网址 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')

多态性

1 什么是多态动态绑定(在继续的背景下使用时,有时也叫做多态性)

多态性是指在不思考实例类型的气象下采用实例

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

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

多态性

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

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

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

鸭子类型

逗比时刻:

  Python崇尚鸭子类型,即‘借使看起来像、叫声音图像而且走起路来像鸭子,那么它正是鸭子’

python程序猿平常依据那种作为来编写程序。举例,借使想编写现存对象的自定义版本,能够承继该目标

也能够成立多个外观和表现像,但与它无别的关联的斩新对象,后者平时用于保存程序组件的松耦合度。

例1:利用规范库中定义的种种‘与公事类似’的对象,纵然那一个目的的劳作格局像文件,但她俩并未有持续内置文件对象的主意

例二:体系类型有两种形象:字符串,列表,元组,但他们直接未有直接的延续关系

美高梅开户网址 40美高梅开户网址 41

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

    def write(self):
        pass

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

例子

封装

【封装】

         隐藏对象的属性和促成细节,仅对外提供公共访问方式。

【好处】 

  1. 将扭转隔断; 

  2. 有利使用;

  3. 增进复用性; 

  4. 加强安全性;

【封装原则】

      一. 将不须要对外提供的剧情都藏匿起来;

      贰. 把质量都掩藏,提供公共艺术对其访问。

村办变量和村办方法

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

村办变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成:_类名__x的形式:

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形

那种自发性别变化形的表征:

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

二.那种变形其实正是本着外部的变形,在外部是心有余而力不足通过__x这几个名字访问到的。

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个接口(函数),只要接口(函数)名、参数不改变,使用者的代码永世无需改换。那就提供3个妙不可言的同盟基础——只怕说,只要接口这么些基础约定不改变,则代码改造不足为虑。

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

美高梅开户网址 43美高梅开户网址 44

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

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

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

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


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

例二:圆的周长和面积

怎么要用property

将三个类的函数定义成特征现在,对象再去行使的时候obj.name,根本不恐怕察觉本人的name是实行了三个函数然后总计出来的,那种特点的利用办法遵照了统一访问的原则

除了,看下

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

python并未在语法上把它们多少个内建到温馨的class机制中,在C++里一般会将兼具的有所的多寡都设置为民用的,然后提供set和get方法(接口)去设置和收获,在python中通过property方法能够兑现

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

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

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

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

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

2个静态属性property本质正是落到实处了get,set,delete两种方式

美高梅开户网址 45美高梅开户网址 46

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

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

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

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

View Code

美高梅开户网址 47美高梅开户网址 48

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

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

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

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

View Code

怎么用?

class Goods:

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

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

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

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


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

classmethod

class Classmethod_Demo():
    role = 'dog'

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

Classmethod_Demo.func()

staticmethod

class Staticmethod_Demo():
    role = 'dog'

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

Staticmethod_Demo.func()

面向对象的更加多表达

面向对象的软件开拓

无数人在学完了python的class机制之后,境遇1个生产中的难点,还是会懵逼,这实际上太常常了,因为任何程序的花费都以先规划后编制程序,python的class机制只可是是壹种编制程序格局,假设你硬要拿着class去和您的标题死磕,变得越来越懵逼都以分分钟的事,在从前,软件的开垦相对简便易行,从任务的辨析到编写程序,再到程序的调治,能够由壹个人或二个小组去做到。不过随着软件规模的快速增大,软件放4面临的主题材料13分复杂,须要思量的要素太多,在3个软件中所发生的错误和潜伏的错误、未知的失实或许达到惊人的等级次序,那也不是在设计阶段就完全消除的。

   
所以软件的开销其实一整套标准,我们所学的只是当中的一小部分,2个全体的支出进度,必要分明每一种阶段的职分,在有限支撑三个品级精确的前提下再拓展下二个等级的劳作,称之为软件工程

    面向对象的软件工程包括下边几个部:

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

   
软件工程中的系统分析阶段,供给分析员和用户结成在共同,对用户的须求做出确切的解析和显著的抒发,从大的上面分析软件系统应该做如何,而不是怎么去做。面向对象的辨析要听从面向对象的概念和艺术,在对职务的剖析中,从客观存在的东西和东西之间的涉嫌,贵南出有关的对象(对象的‘特征’和‘技巧’)以及对象之间的联系,并将装有同样属性和行事的靶子用三个类class来标记。

    建立一个能反映那是干活情景的须求模型,此时的模型是粗略的。

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

    根据面向对象分析阶段形成的须求模型,对每一部分各自打开具体的布置。

   
首先是类的设计,类的设计大概带有三个档次(利用连续与派生机制)。然后以那些类为基础提议程序设计的思绪和艺术,包蕴对算法的布置。

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

叁 面向对象编制程序(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只是十分的小的3个有的。

   
对于全栈开荒的你的话,那八个阶段都有了,对于简易的难题,不必严俊依照这些四个等级张开,往往由程序设计者根据面向对象的法子开始展览程序设计,包罗类的宏图和顺序的宏图

 

多少个概念的认证

 

1.面向对象的程序设计看起来高大上,所以我在编制程序时就应有保险通篇class,那样写出的先后一定是好的主次(面向对象只适合那个可扩大性供给相比较高的情况)

二.广大人爱不释手说面向对象三大特征(那是从哪传出来的,封装,多态,承继?漏洞太多太多,好吧权且称为三大特色),那么本人在依据面向对象编制程序时,作者一定要让作者定义的类中完全的隐含那两种特性,那样写一定是好的主次

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

3.类有类脾气,实例有实例属性,所以大家在定义class时必然要定义出那么多少个类属性,想不到怎么做,这就全力的想,定义的更加多越牛逼

那就犯了贰个严重的失实,程序越早面向对象,死的越早,为什么面向对象,因为大家要将数据与功能整合到一块儿,程序全体的布局都尚未出来,可能说要求思量的难题你都并未有搞掌握个捌9不离十,你就起来面向对象了,那就招致了,你在那边干想,自感到想通了,定义了一批属性,结果后来又都用不到,可能想不通到底应该定义啥,那就径直想吧,想着想着就疯了。

你见过哪家商场要耗费二个软件,上来就起来写,料定是多次的开会切磋陈设,请看第九节。

面向对象常用术语

抽象/实现

架空指对切实世界难题和实体的真面目表现,行为和特色建立模型,建立叁个皮之不存毛将焉附的子集,能够用于
绘程序结构,从而完结那种模型。抽象不仅囊括那种模型的多少属性,还定义了这个数量的接口。

对某种抽象的贯彻正是对此数据及与之皮之不存毛将焉附接口的现实化(realization)。现实化这几个进度对于客户
程序应当是透明而且无关的。 

封装/接口

装进描述了对数码/新闻实行隐蔽的观念意识,它对数据属性提供接口和走访函数。通过此外客户端直接对数据的拜会,无视接口,与封装性都以违背的,除非程序猿允许那个操作。作为贯彻的
壹部分,客户端根本就不需求精晓在包装之后,数据属性是何等组织的。在Python中,全体的类属性都以当面包车型地铁,但名字或许被“混淆”了,以阻滞未经授权的造访,但仅此而已,再未有任何防范措施了。那就要求在陈设时,对数据提供对应的接口,防止客户程序通过非僧非俗的操作来存取封装的多少属性。

留意:封装绝不是相等“把不想让旁人看来、今后只怕退换的东西用private隐藏起来”

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

(注意:对外透明的情趣是表面调用者能够顺遂的收获和谐想要的其余功用,完全意识不到中间细节的留存)

合成

合成扩展了对类的
述,使得多少个不等的类合成为三个大的类,来消除现实主题材料。合成 述了
3个那个复杂的连串,举例二个类由其余类组成,越来越小的机件也可能是其余的类,数据属性及表现,
全数那几个合在一齐,相互是“有二个”的关系。

派生/继承/承袭结构

派生描述了子类衍生出新的特性,新类保留已存类类型中有着必要的数额和行事,但允许修改或然其余的自定义操作,都不会修改原类的定义。
一连描述了子类属性从祖先类承继那样壹种格局
后续结构意味着多“代”派生,能够述成3个“族谱”,一连的子类,与祖先类都有涉嫌。

泛化/特化

基于承接
泛化表示具有子类与其父类及祖先类有1致的风味。
特化描述全部子类的自定义,也正是,什么性质让它与其祖先类不相同。

多态与多态性

多态指的是同样种东西的多样意况:水那种事物有各个不一样的状态:冰,水蒸气

多态性的定义提议了对象怎么样通过她们手拉手的特性和动作来操作及走访,而不需考虑他们实际的类。

冰,水蒸气,都卫冕于水,它们都有一个同名的格局正是产生云,可是冰.变云(),与水蒸气.变云()是一心分裂的长河,固然调用的法子都一致

自省/反射

反省也称作反射,这几个脾性展现了某目标是何等在运维期获得自身音信的。假使传八个对象给您,你能够查出它有哪些本领,这是1项庞大的特征。借使Python不援救某种情势的自省效能,dir和type内建函数,将很难平常干活。还有那些特殊性质,像__dict__,__name__及__doc__

发表评论

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

网站地图xml地图