新建的类可以继承一个或多个父类(python支持多

作者: 编程  发布:2019-11-20
 1 class People:
 2     def __init__(self, name, age):
 3         self.__name = name
 4         self.__age = age
 5 
 6     def tell_info(self):
 7         print('<name:%s age:%s>' % (self.__name, self.__age))
 8 
 9     def set_info(self, name, age):
10         if type(name) is not str:
11             print('名字必须是str类型傻叉')
12             return
13         if type(age) is not int:
14             print('年龄必须是int类型傻叉')
15             return
16         self.__name = name
17         self.__age = age
18 
19 
20 obj = People('egon', 18)
21 obj.set_info('EGON', '18')
22 obj.tell_info()

意气风发、面向过程与面向对象的简单介绍

1.什么是包裹

字面上的情致就是,把东西隐瞒起来了。

在python中的封装正是把 类中的属性(变量、函数卡塔 尔(阿拉伯语:قطر‎掩没起来

也得以成立二个外观和作为像,但与它无其余关联的全新对象,前者平常用于保存程序组件的松耦合度。

 1 class Foo:
 2     xxx = 111
 3 
 4 class Bar:
 5     yyy = 222
 6 
 7 obj = Foo()
 8 obj.attr = Bar()
 9 
10 print(obj.xxx)
11 >>>111
12 print(obj.attr.yyy)
13 >>>222

1.继承:

接轨是豆蔻梢头种创建新类的主意,在python中,新建的类可以持续三个或多少个父类,父类又可称为基类或超类,新建的类称为派生类或子类

三、多态

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

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

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

  封: 代表将贮存在于名称空间中的名字给藏起来,这种隐形对外不对内

在一而再再而三中, 假设子类有的艺术就试行子类的 假如子类未有的形式就举办父类的。 语法: class 类名(父类名卡塔 尔(英语:State of Qatar): 假诺不点名世袭的父类,暗中认可世袭 object 子类能够使用父类的享有属性和格局。 假使子类有行家级的秘诀就实践自身的。 没救就进行父类, 子类,父类都并未有,就报错。 子类中调用父类: 在类内—— super (子类名,self).方法名(卡塔尔国 在类外—— super (子类名,对象名)。方法名(卡塔尔国

图片 1

python中类的继续分为:单世襲和多世袭

图片 2图片 3

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
    pass

View Code

提醒:若无一些名基类,python的类会默许世袭object类,object是具备python类的基类,它提供了有个别广阔方式(如__str__)的实现。

3.怎么用包装

在python中用双下划线起首的艺术将质量隐讳起来(设置成私有的卡塔 尔(英语:State of Qatar)

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__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这个名字访问到。

PS:

*1.这种体制也并从未当真含义上限定大家从表面直接访问属性,知道了类名和总体性名就可以拼著名字:_类名__质量,然后就能够访谈了,如a._A__N,**即这种操作并非严刻意义上的范围外界采访,仅仅只是风流倜傥种语法意义上的变形,首要用来界定外界的直接访问。


2.变形的历程只在类的概念时发出一遍,在概念后的赋值操作,不会变形

图片 4

3.在三回九转中,父类如若不想让子类覆盖自身的方法,能够将艺术定义为私有的

 

图片 5图片 6

#正常情况
>>> 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

躬行实践代码

 

 

 

民用方法

3.在接二连三中,父类假诺不想让子类覆盖本身的主意,能够将艺术定义为私有的

#正常情况
>>> 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.为啥要用组合

property属性:

图片 7图片 8

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

例子1

图片 9图片 10

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)

例子2

图片 11图片 12

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

例子3

#瞩目:这时的特征area和perimeter无法被赋值
c.area=3 #为特性area赋值
''' 抛出十一分: AttributeError: can't set attribute

 

 

何以要用property

将三个类的函数定义成特征以往,对象再去行使的时候obj.name,根本不能察觉自个儿的name是实行了叁个函数然后总结出来的,这种天性的利用方法安分守纪了联合访谈的基准

除开,看下

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

 

图片 13

python并未在语法上把它们多少个内建到协和的class机制中,在C++里平时会将装有的装有的多寡都设置为私有的,然后提供set和get方法(接口卡塔 尔(阿拉伯语:قطر‎去设置和得到,在python中通过property方法能够兑现

图片 14图片 15

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'

View Code

多少个静态属性property本质正是兑现了get,set,delete二种情势

图片 16图片 17

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

图片 18图片 19

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

图片 20图片 21

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     # 删除商品原价

View Code

 

3、怎么样用多态

动物有多样样子:人,狗,猪

图片 22图片 23

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

Animal

文件有各个形状:文本文件,可推行文件

图片 24图片 25

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

File

PS:

1.虚无基类是不可能实例化的

2.一连抽象基类的类,必得重写其抽象父类中的抽象方法

个人变量和村办方法

在python中用双下划线开头的办法将质量蒙蔽起来(设置成私有的卡塔尔国

面向对象-组合

包裹与扩大性:

封装在于显然区分内外,使得类实现者可以改革封装内的事物而不影响外界调用者的代码;而外界使用用者只驾驭一个接口(函数),只要接口(函数卡塔 尔(英语:State of Qatar)名、参数不改变,使用者的代码长久无需更动。那就提供八个好好的合营底子——可能说,只要接口这么些底蕴约定不改变,则代码改动微不足道。

#类的设计者
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接口的人来说根本无需改动自己的代码,就可以用上新功能

2.为什么要用封装

包装的真谛在于明显内外

对外隐蔽(类的外表只可以通过大家提供的接口对类内部的掩饰属性就行拜见卡塔 尔(英语:State of Qatar)

对内开花(在类的内部能够直接接纳隐蔽属性卡塔 尔(阿拉伯语:قطر‎

 

封装数据(变量卡塔 尔(英语:State of Qatar)将数据隐蔽并非我们的指标,能够通过接口的艺术将数据暴光给类外面使用,在接口中大家得以对数码进行节制,达成对数据的主宰

图片 26图片 27

class Teacher:
    def __init__(self,name,age):
        # self.__name=name
        # self.__age=age
        self.set_info(name,age)

    def tell_info(self):
        print('姓名:%s,年龄:%s' %(self.__name,self.__age))
    def set_info(self,name,age):
        if not isinstance(name,str):
            raise TypeError('姓名必须是字符串类型')
        if not isinstance(age,int):
            raise TypeError('年龄必须是整型')
        self.__name=name
        self.__age=age


t=Teacher('egon',18)
t.tell_info()

t.set_info('egon',19)
t.tell_info()

演示代码

装进方法(函数卡塔 尔(阿拉伯语:قطر‎关键指标隔断复杂度,将类中多少个函数组合,提供多少个对外封装好的接口,供使用者调用,而调用者没有必要思考接口内复杂的贯彻进度,简化调用

图片 28图片 29

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

隔离复杂度的例子

身体力行代码

property属性

怎么着是特点property

property是风度翩翩种极度的质量,访谈它时会执行业作风流罗曼蒂克段成效(函数卡塔尔然后再次回到值

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

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

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property   #让最下面的pl.bmi省去了后面的括号,变成了print(pl.bmi)

  def bmi(self): 
    return self.weight / (self.height**2) 

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

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

    @property  #property  实际上是把类的方法变成了属性,所以类调用属性不需要加括号  c.area
    def area(self):   #类调用方法要加括号  c.area()
        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'

二个静态属性property本质正是得以完成了get,set,delete二种办法   (查看,改正,删除卡塔尔备考:不太明白

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

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     # 删除商品原价

  进而收缩类与类之间代码冗余

2.面向对象:

  定义:面向对象的主次设计的中央是目的(天公式思维卡塔尔国,要驾驭对象为什么物,必得把本人就是天公,天神眼里尘世存在的万物皆为指标,不设有的也得以创制出来。

  优点:化解了程序的扩大性。对某二个指标单独订正,会立时反映到全体体系中,如对娱乐中一人物参数的特色和才能改过都超轻巧。

  劣势:可控性差,不可能向面向进度的程序设计流水生产线式的能够很精准的揣摸难点的管理流程与结果,面向对象的程序生机勃勃旦开端就由对象时期的相互解决难题,即正是天神也无可奈何预测最后结出。

二、封装

民用变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__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,**引用的正是变形的结果**。

2.这种变形其实便是本着外界的变形,在外表是心余力绌透过__x这些名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变变成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开始的习性在后续给子类时,子类是束手无策隐讳的。**

 

这种变形须求在乎的主题材料是:

1.这种体制也并不曾真正含义上节制咱们从外表直接访问属性,知道了类名和品质名就足以拼盛名字:_类名__属性,然后就足以访谈了,如a._A__N

2.变形的进度只在类的中间生效,在概念后的赋值操作,不会变形

图片 30

1.如何是整合

3.封装:

【封装】

         掩盖对象的天性和落到实处细节,仅对外提供公共访谈格局。

【好处】 

  1. 将扭转隔开; 

  2. 方便人民群众使用;

  3. 增进复用性; 

  4. 增长安全性;

【封装原则】

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

      2. 把质量都规避,提供公共艺术对其访谈。

一、继承

多态性是指在不思谋实例类型的场面下选拔实例

  封装数据属性:

三、面向对象的三结合

2.为啥要有世襲

子类会“”遗传”父类的属性,进而解决代码重用难点,收缩代码的冗余

例1:利用标准库中定义的种种‘与公事肖似’的对象,固然这几个指标的劳作方式像文件,但他们从未继续内置文件对象的章程

面向对象-多态与多态性

1.初识类和指标

对象:

(1卡塔 尔(英语:State of Qatar)指任何物体(‘万事万物皆为目标’卡塔 尔(阿拉伯语:قطر‎

(2卡塔尔国分裂的靶子有例外的习性,万物都有浮动——对象的秘诀。

(3卡塔 尔(阿拉伯语:قطر‎对于此外贰天质量都享有3个方面:属性所属的对象,属性的值,属性的称呼。对象有个别属性并不是风流倜傥层不改变的。

类:

(1卡塔尔国近墨者黑——类定义对象——饼干模具分娩饼干

(2卡塔 尔(阿拉伯语:قطر‎类是由一样的特色结合,类是概念同少年老成类具备目的的变量和措施的蓝图。

(3卡塔 尔(英语:State of Qatar)对象的共性抽象为类,类的实例化就是指标。

2、为何要用多态   

用基类创造后生可畏套统风姿罗曼蒂克的规规矩矩,强制子类去依照(使用抽象类达成卡塔 尔(阿拉伯语:قطر‎,这样便得以
在实际不是考虑对象实际品种的前提下而直白使用对象下的措施

staticmethod   在一起面向对象的次第中,要是三个函数既和队象没涉及也和类不妨,那么就用staticmethod将那些情势成为静态方法

class Staticmethod_Demo():
    role = 'dog'

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

Staticmethod_Demo.func()

类措施和静态方法能够被类调用

对象能够调用类方法和静态方法,日常用类名调用

类措施  有二个暗中同意参数  cls    代表这几个类  cls

 

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

这种自动变形的风味:

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

2.这种变形其实就是针对外部的变形,在外表是爱莫能助通过__x这几个名字访谈到的。

3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变产生了:_父类名__x,即双下滑线初步的质量在一连给子类时,子类是不可能掩瞒的。**

这种变形供给小心的难点是:

1.这种体制也并从未当真含义上节制我们从表面直接待上访谈属性,知道了类名和属性名就能够拼著名字:_类名__质量,然后就能够访谈了,如a._A__N

2.变形的历程只在类的定义是产生二次,在概念后的赋值操作,不会变形

5.派生与重用

派生:子类定义自身新的属性,假使与父类同名,以子类本身的为准

图片 31图片 32

# 父类
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def func1(self):
        print('People.func1')


# 子类 派生自己的属性
class Teacher(People):
    def __init__(self, name, age, sex, level, salary):
        self.name = name
        self.age = age
        self.sex = sex

        self.level = level
        self.salary = salary

    def func1(self):
        print('Teacher.func1')


# 实例化
tea1 = Teacher('fixd', 18, 'male', 9, 3.1)
print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)

# 结果
fixd 18 male 9 3.1

演示代码

选定:在子类派生出的新议程中录取父类的效应

方法风姿罗曼蒂克:毫不掩瞒地调用(其实与后续未有啥样关联的卡塔尔

# 父类
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


# 子类 "指名道姓" 调用父类的属性
class Teacher(People):
    def __init__(self, name, age, sex, level, salary):
        People.__init__(self, name, age, sex)
        self.level = level
        self.salary = salary

办法二、super()调用(严俊注重于继续卡塔尔

*  ps:super()的重返值是多个独特的对象,该对象特别用来调用父类中的属性*

*  明白:在python第22中学,须求super(自身的类名,self)*

# 父类
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


# 子类 super() 调用父类的属性
class Teacher(People):
    def __init__(self, name, age, sex, level, salary):       
        super().__init__(name, age, sex)
        self.level = level
        self.salary = salary 

细心:以上三种办法都足以动用,在其实的编码专门的学问中,推荐应用统风姿洒脱的生龙活虎种方法

 

图片 33图片 34

#super()会严格按照mro列表从当前查找到的位置继续往后查找
class A:
    def test(self):
        print('A.test')
        super().f1()
class B:
    def f1(self):
        print('from B')
class C(A,B):
    pass

c=C()
print(C.mro()) #C->A->B->object


c.test()

mro列表

 

例2:系列类型有二种形象:字符串,列表,元组,但她们径直未有平素的接续关系

  装: 往容器/名称空间里存入名字

1.类的宣示:

def functionName(args):
     '函数文档字符串'
      函数体 

'''
class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
class Data:
    pass

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

1.哪些世襲

三回九转是风度翩翩种创立新类的秘诀,新建的类可以世襲一个或五个父类(python支持多一连卡塔 尔(阿拉伯语:قطر‎,父类又可称之为基类或超类,新建的类称为派生类或子类。**

classmethod   一个主意成为类中的方法,这一个点子直接就能够被调用

class Classmethod_Demo():
    role = 'dog'

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

Classmethod_Demo.func()
 1 class People:
 2     def __init__(self, name):
 3         self.__name = name
 4 
 5     @property
 6     def name(self):
 7         return '<名字:%s>' % self.__name
 8 
 9     @name.setter
10     def name(self, obj):
11         if type(obj) is not str:
12             print('name必须为str类型')
13             return
14         self.__name = obj
15 
16     @name.deleter
17     def name(self):
18         print('不让删')
19 
20 obj = People('egon')
21 del obj.name
22 print(obj.__dict__)

2.多态:

多态指的是生龙活虎类东西有多样造型

动物有各个形象:人,狗,猪

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

豆蔻年华 什么是多态动态绑定(在再而三的背景下使用时,有的时候也称为多态性卡塔尔国

多态性是指在不思虑实例类型的场合下使用实例:

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

多态性分为静态多态性和动态多态性:

*  静态多态性:如别的项目都得以用运算符+举行演算*

*  动态多态性:如下*

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

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

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

  

潜水鸭类型

逗比时刻:

  Python崇尚绒鸭类型,即‘假设看起来像、叫声音图像而且走起路来像红鸭,那么它就是赤麻鸭’

python技师通常遵照这种展现来编写程序。比如,要是想编写现成对象的自定义版本,能够世袭该对象

也足以成立叁个外观和作为像,但与它无其余关联的全新对象,前面一个日常用于保存程序组件的松耦合度。

例1:利用标准库中定义的各样‘与公事雷同’的对象,就算那个指标的劳作方法像文件,但她俩从未继续内置文件对象的章程

例2:种类类型有三种样子:字符串,列表,元组,但她们径直未有从来的世袭关系

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

    def write(self):
        pass

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

3.怎么采纳继续

eg:

class ParentClass1: # 定义父类1
    pass

class ParentClass2: # 定义父类2
    pass

class Subclass1(ParentClass1): # 单继承 父类1
    pass

class Subclass2(ParentClass1,ParentClass2):  # 多继承多个父类  父类1 父类2
    pass

print(Subclass1.__bases__)  # 查看所有父类信息
print(Subclass2.__bases__)  # 查看所有父类信息

结果:以元组的形式返回
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

 

多态性

 1 class OldboyPeople:
 2     school = 'Oldboy'
 3 
 4     def __init__(self, name, age, sex, ):
 5         self.name = name
 6         self.age = age
 7         self.sex = sex
 8 
 9 
10 class OldboyStudent(OldboyPeople):
11     def __init__(self, name, age, sex, score=0):
12         OldboyPeople.__init__(self, name, age, sex)
13         self.score = score
14         self.courses = []
15 
16     def choose_course(self):
17         print('%s choosing course' % self.name)
18 
19     def tell_all_course(self):
20         print(('学生[%s]选修的课程如下' % self.name).center(50, '='))
21         for obj in self.courses:
22             obj.tell_info()
23         print('=' * 60)
24 
25 
26 class OldboyTeacher(OldboyPeople):
27     def __init__(self, name, age, sex, level):
28         OldboyPeople.__init__(self, name, age, sex)
29         self.level = level
30         self.courses = []
31 
32     def score(self, stu, num):
33         stu.score = num
34 
35     def tell_all_course(self):
36         print(('老师[%s]教授的课程如下' % self.name).center(50, '*'))
37         for obj in self.courses:
38             obj.tell_info()
39         print('*' * 70)
40 
41 
42 class Course:
43     def __init__(self, c_name, c_price, c_period):
44         self.c_name = c_name
45         self.c_price = c_price
46         self.c_period = c_period
47 
48     def tell_info(self):
49         print('<课程名:%s 价钱:%s 周期:%s>' % (self.c_name, self.c_price, self.c_period))
50 
51 
52 # 创建课程对象
53 python = Course('python全栈开发', 1900, '5mons')
54 linux = Course('linux架构师', 900, '3mons')
55 
56 stu1 = OldboyStudent('刘二蛋', 38, 'male')
57 stu1.courses.append(python)
58 stu1.courses.append(linux)
59 stu1.tell_all_course()
60 
61 tea1 = OldboyTeacher('egon', 18, 'male', 10)
62 tea1.courses.append(python)
63 tea1.tell_all_course()

关于self

self:在实例化时自动将指标/实例本人传给__init__的首先个参数,你也得以给她起分其余名字,然则平常人都不会这么做。
因为你瞎改外人就不认得

类属性的增补:

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

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

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

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

4.特性(property)

怎样是特色

property是意气风发种极其的习性,访谈它时会施行业作风姿洒脱段作用(函数卡塔 尔(英语:State of Qatar)然后再次来到值

eg:

图片 35图片 36

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

功用描述

图片 37图片 38

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 * self.height)

# egon=People('egon',75,1.80)
#
# egon.bmi=egon.weight / (egon.height * egon.height)
# print(egon.bmi)
#
# yl=People('yangli',85,1.74)
# yl.bmi=yl.weight / (yl.height * yl.height)
# print(yl.bmi)


# 首先需要明确。bmi是算出来的,不是一个固定死的值,也就说我们必须编写一个功能,每次调用该功能
#都会立即计算一个值
egon=People('egon',75,1.80)
yl=People('yangli',85,1.74)

# 但很明显人的bmi值听起来更像一个名词而非动词
# print(egon.bmi())
# print(yl.bmi())


# 于是我们需要为bmi这个函数添加装饰器,将其伪装成一个数据属性
# egon.weight=70
# print(egon.bmi) #21.604938271604937,调用egon.bmi本质就是触发函数bmi的执行,从而拿到其返回值
# print(yl.bmi)

演示代码

 

为什么要用脾性

将三个类的函数定义成特色今后,对象再去采取的时候obj.name,根本无法察觉自个儿的name是进行了二个函数然后总结出来的,这种特性的利用情势服从了归总访谈的规格

PS:

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

python并不曾在语法上把它们八个内建到和煦的class机制中,能够通过property方法落成

图片 39图片 40

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'

演示代码

 

逗比全日:

  通过为某叁个对象加多属性(属性的值是其余三个类的指标)的措施,能够直接地将几个类关联/整合/组合到一块

后续: 大规模到校范围 抽象: 范围进一层大,共性更小 派生:父类的底子上发生子类——派生类 派生方法: 父类里不曾的,可是i子类里部分 派生属性: 方法的重写: 父类里有的艺术,在子类里再次完结。

1、什么是多态

* 多态指的是千篇意气风发律种东西二种造型*

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

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

1.怎么是多态

1.怎么着是构成?

答:软件重用的显要艺术除了三番四次之外还应该有其它大器晚成种方法,即:组合

组成指的是,在二个类中以此外多少个类的对象作为数据属性,称为类的结缘

组合表现的是:  谁有什么的关系。
例如:  人有武器 、   学校有学生  、 学生有课程

组成例子1:

class Weapon:
    def prick(self, obj):  # 这是该装备的主动技能,扎死对方
        obj.life_value -= 500  # 假设攻击力是500

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称;
        self.weapon = Weapon()  # 给角色绑定一个武器;

egg = Person('egon')
egg.weapon.prick() 
#egg组合了一个武器的对象,可以直接egg.weapon来使用组合类中的所有方法

结合例子2:

圆环是由五个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是当中圆的周长加上国外国语高校表圆的周长。
那时候,我们就率先完毕一个圆形类,总计叁个圆的周长和面积。然后在"环形类"中组成圆形的实例作为友好的性格来用

图片 41图片 42

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

View Code

组合例子3:

用结合的点子建构了类与构成的类之间的关系,它是生龙活虎种‘有’的涉嫌,比如教授有生辰,教师教python课程

图片 43图片 44

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)
''' 
运行结果: 
1 27 
python 28000 4 months 

View Code

当类之间有醒目区别,并且异常的小的类是非常的大的类所须求的组件时,用整合相比较好

4、多态性

1.什么样是多态动态绑定(在继续的背景下行使时,又称之为多态性卡塔尔

多态性是指在不思考实力类型的情况下利用实例

图片 45图片 46

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

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

解释

2.为什么要用多态性(多态性的功利卡塔尔

  • 追加了程序的狡滑

    稳步,不论对象千变万化,使用者都以均等种样式去调用

  • 扩张了前后相继的可扩展性

    透过世袭animal类创立了三个新的类,使用者没有必要改过自个儿的代码,还是用func(animal)去调用

图片 47图片 48

>>> class Cat(Animal): #属于动物的另外一种形态:猫
...     def talk(self):
...         print('say miao')
... 
>>> def func(animal): #对于使用者来说,自己的代码根本无需改动
...     animal.talk()
... 
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变,就能调用猫的talk功能
say miao

'''
这样我们新增了一个形态Cat,由Cat类产生的实例cat1,使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法,即func(cat1)
'''

示范代码

 

3.野鸭类型

Python中崇尚海番鸭类型(若是看起来像,叫声音图像並且走起路像秋沙鸭,那么它正是秋沙鸭卡塔尔国

透过三回九转完成的多态性,具备强耦合性;

硬尾鸭类型,通过创制叁个外观和作为像,但与原类型毫非亲非故系的全新对象,具备松耦合性;

图片 49图片 50

#其实大家一直在享受着多态性带来的好处,
#比如Python的序列类型有多种形态:字符串,列表,元组,多态性的体现
#
#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)

演示代码

 

村办方法

3.在继续中,父类假如不想让子类覆盖本身的主意,能够将艺术定义为私有的

这种变形须求小心的主题材料是:

1.这种体制也并未当真含义上节制大家从表面直接访问属性,知道了类名和品质名就足以拼著名字:_类名__性子,然后就能够访谈了,如a._A__N

2.变形的进度只在类的中间生效,在概念后的赋值操作,不会变形

图片 51

 

2.类有二种效应:

脾性引用:

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


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

实例化:类名加括号就是实例化,会自行触发__init__函数的周转,能够用它来为种种实例定制本身的本性

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

实例化的进度便是类——>对象的经过

本来大家唯有三个Person类,在这里个进度中,产生了叁个egg对象,有投机械和工具体的名字、攻击力和生命值。

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

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;

    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")

aray = Person('zbk')
print(aray.name)   #查看属性直接 对象名.属性名
print(aray.walk())  #调用方法,对象名.方法名()

5.属性查找

'''
1、新式类:
    继承object的类,以及该类的子类,都是新式类

    在python3中,如果一个类没有指定继承的父类,默认就继承object
    所以说python3中所有的类都是新式类

2、经典类(只有在python2才区分经典类与新式类):
    没有继承object的类,以及该类的子类,都是经典类
'''

单世袭名称空间的寻觅顺序:

指标自己-------->>当前类-------->>父类-------->>object      # 查找不到,报错

多一而再名称空间的检索顺序:

图片 52

图片 53

在菱形继承的背景下,查找属性
1、精华类:深度优先
2、新式类:广度优先

 

  Python崇尚钻水鸭类型,即‘就算看起来像、叫声音图像并且走起路来像红鸭,那么它正是绿头鸭’

 1 class Foo1:
 2     pass
 3 class Foo2:
 4     pass
 5 class Foo3:
 6     pass
 7 
 8 class Bar:
 9     pass
10 
11 obj_from_bar=Bar()
12 
13 obj1=Foo1()
14 obj2=Foo2()
15 obj3=Foo3()
16 
17 obj1.attr1=obj_from_bar
18 obj2.attr2=obj_from_bar
19 obj3.attr3=obj_from_bar

1.面向进程:

  定义:面向进度的程序设计的基本是经过(流水生产线式思维卡塔尔,进度即消逝难点的手续,面向进度的安顿就好比精心设计好一条流水生产线,思谋周到何时管理什么东西。

  优点:非常大的骤降了写程序的复杂度,只供给顺着要进行的步调,聚积代码就可以。

  劣势:生龙活虎套流水生产线大概流程就是用来缓和一个题材,代码一着不慎满盘皆输。

4.持续与虚幻(先抽象再持续卡塔 尔(英语:State of Qatar)

先抽象:收取对象时期形似之处拿到了类,在计算类与类之间的貌似获得父类

再持续:(子类世襲父类,子类能够遗传父类属性)是基于抽象的结果,通过编制程序语言去完毕它,分明是先经历抽象那几个历程,能力通过一而再的法子去表明出抽象的协会。

钻水鸭类型

  组合指的是某一个指标具备贰特性质,该属性的值是其余一个类的靶子

四、面向对象的三大特点

python技师经常依照这种行为来编写程序。比如,假若想编写现存对象的自定义版本,能够一连该指标

  总结:

个人方法:

**3.在继续中,父类要是不想让子类覆盖本身的秘籍,能够将艺术定义为私有的**

 

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B


#把fa定义成私有的,即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A

打包与扩大性

封装在于鲜明区分内外,使得类完毕者能够校订封装内的事物而不影响外界调用者的代码;而外界使用用者只明白八个接口(函数),只要接口(函数卡塔 尔(阿拉伯语:قطر‎名、参数不改变,使用者的代码永恒不必要退换。那就提供叁个理想的同盟根底——也许说,只要接口那些底蕴约定不改变,则代码改造不足多虑。

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


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


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


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

 

Python推崇的是钻水鸭类型,只要您叫的动静像潜水鸭,而且你走路的指南也像绒鸭,那你即是树鸭

二、面向对象的家庭成员介绍

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

    def write(self):
        pass

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

    将数据属性掩饰起来,类外就不能够直接操作属性,须要类内部开发三个接口,让外界的使用能够直接地操作属性,可以在接口钦赐制自便的垄断(monopoly卡塔尔国逻辑,进而严控使用者对品质的操作

一 什么是多态动态绑定(在那起彼伏的背景下使用时,有的时候也称为多态性卡塔尔国

面向对象-封装

封装

【封装】

         隐蔽对象的属性和贯彻细节,仅对外提供公共访谈方式。

【好处】 

  1. 将转换隔开; 

  2. 有利使用;

  3. 加强复用性; 

  4. 增长安全性;

【封装原则】

      1. 将无需对外提供的内容都藏匿起来;

      2. 把品质都走避,提供公共艺术对其访谈。

    1. __初阶的性质达成的隐讳仅仅只是豆蔻梢头种语法意义上的变形,并不会真正约束类外部的会见

 1 import abc
 2 
 3 
 4 class Animal(metaclass=abc.ABCMeta):
 5     @abc.abstractmethod
 6     def speak(self):
 7         pass
 8 
 9     @abc.abstractmethod
10     def run(self):
11         pass
12 
13 
14 
15 class People(Animal):
16     def speak(self):
17         print('say hello')
18 
19     def run(self):
20         pass
21 
22 
23 class Dog(Animal):
24     def speak(self):
25         print('汪汪汪')
26 
27     def run(self):
28         pass
29 
30 
31 class Pig(Animal):
32     def speak(self):
33         print('哼哼哼')
34 
35     def run(self):
36         pass
37 
38 
39 obj1 = People()
40 obj2 = Dog()
41 obj3 = Pig()

3.怎么着封装

    2. 该变形操作只在类定义阶段检验语法时发生一遍,类定义阶段之后新扩充的__始于的性质并不会变形

1.什么样是包装

property装饰器是用来将类内的函数属性伪装成数据属性

  多态指的是意气风发致种/类东西的差别形态

  在类钦点义的性质前加__开头(没有__结尾)

  多态性:在多态的背景下,可以在毫无思虑对象实际项目标前提下而一贯接收对象

  Animal()  #父类只是用来树立规范的,不能够用来实例化,更无需兑现内部的情势

 

面向对象-property

 1 class Disk:
 2     def read(self):
 3         print('Disk read')
 4 
 5     def write(self):
 6         print('Disk write')
 7 
 8 
 9 class Memory:
10     def read(self):
11         print('Mem read')
12 
13     def write(self):
14         print('Mem write')
15 
16 
17 class Cpu:
18     def read(self):
19         print('Cpu read')
20 
21     def write(self):
22         print('Cpu write')
23 
24 
25 obj1 = Disk()
26 obj2 = Memory()
27 obj3 = Cpu()
28 
29 obj1.read()
30 obj2.read()
31 obj3.read()

3.什么用多态

 

  封装函数属性: 隔开分离复杂度

2.怎么要卷入

3.什么样用整合

 

 1 class Foo:
 2     def __f1(self):  # _Foo__f1
 3         print('Foo.f1')
 4 
 5     def f2(self):
 6         print('Foo.f2')
 7         self.__f1()  # obj._Foo__f1()
 8 
 9 
10 class Bar(Foo):
11     def __f1(self):  # _Bar__f1
12         print('Bar.f1')
13 
14 
15 obj = Bar()
16 
17 >>>Foo.f2
18 >>>Foo.f1

 

    3. 假使父类不想让子类覆盖本人的品质,能够在质量前加__开头

 1 class ATM:
 2     def __card(self):
 3         print('插卡')
 4 
 5     def __auth(self):
 6         print('用户认证')
 7 
 8     def __input(self):
 9         print('输入取款金额')
10 
11     def __print_bill(self):
12         print('打印账单')
13 
14     def __take_money(self):
15         print('取款')
16 
17     def withdraw(self):
18         self.__card()
19         self.__auth()
20         self.__input()
21         self.__print_bill()
22         self.__take_money()
23 
24 
25 a = ATM()
26 a.withdraw()

 

本文由9159.com发布于编程,转载请注明出处:新建的类可以继承一个或多个父类(python支持多

关键词: