Python---面向对象(一)
本文参考资料:
http://www.cnblogs.com/wupeiqi/p/4493506.html
http://www.cnblogs.com/Eva-J/articles/7293890.html
http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label1
Python基础教程(二)、Python编程:从入门到实践
一 为什么要有面向对象程序设计
面向过程--适用于简单、一次性的任务
优点:复杂度的问题流程化,进而简单化(一个复杂的问题,分成一个个小的步骤去实现,实现小的步骤将会非常简单)
缺点:扩展性差,不易维护。改一个组件,牵一发而动全身。
应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,Git,以及Apache HTTP Server等。
二 面向对象简介
面向对象编程是最有效的软件编写方法之一。在面向对象编程中,
你编写表示现实世界中的事物和情景的类,并基于这些类来创建对象。
编写类时,你定义一大类对象都有的通用行为。基于类创建对象时,
每个对象都自动具备这种通用行为,然后可根据需要赋予每个对象独
特的个性。使用面向对象编程可模拟现实情景,其逼真程度达到了令
你惊讶的地步。
优点:易扩展,更加贴近人类思维的特点, 更加脱离机器思维,是一次软件设计思想上的飞跃。
缺点:复杂度高、不可预知
应用场景:互联网应用、游戏、企业内部软件
三 类与对象
类
鸟是鸟类的实例。这就是一个有很多子类的的一般(抽象)类:看到的鸟可能属于子类“百灵鸟”。可以将“鸟类”想象成所有鸟的集合,而“百灵鸟”是其中的一个子集。当一个对象所属的类是另外一个对象所属类的子集时,前者就被称为后者的子类(subclass),所以“百灵鸟类”是“鸟类”的子类。相反,“鸟类”是“百灵鸟类”的超类(superclass).
在现实世界中:先有对象,再有类
世界上肯定是先出现各种各样的实际存在的物体,然后随着人类文明的发展,人类站在不同的角度总结出了不同的种类,如人类、动物类、植物类等概念
也就说,对象是具体的存在,而类仅仅只是一个概念,并不真实存在
在程序中:务必保证先定义类,后产生对象
这与函数的使用是类似的,先定义函数,后调用函数,类也是一样的,在程序中需要先定义类,后调用类
不一样的是,调用函数会执行函数体代码返回的是函数体执行的结果,而调用类会产生对象,返回的是对象
PS:
1. 站的角度不同,定义出的类是截然不同的,详见面向对象实战之需求分析
2. 现实中的类并不完全等于程序中的类,比如现实中的公司类,在程序中有时需要拆分成部门类,业务类......
3. 有时为了编程需求,程序中也可能会定义现实中不存在的类,比如策略类,现实中并不存在,但是在程序中却是一个很常见的类
对象
用变量表示特征,用函数表示技能,因而具有相同特征和技能的一类事物就是‘类’,对象是则是这一类事物中具体的一个。
类的相关知识
创建类
class Person: #定义一个人类role = 'person' #人的角色属性都是人def walk(self): #人都可以走路,也就是有一个走路方法,也叫动态属性print("person is walking...")
类有两种作用:属性引用和实例化
属性引用(类名.属性)
class Person: #定义一个人类role = 'person' #人的角色属性都是人def walk(self): #人都可以走路,也就是有一个走路方法print("person is walking...")print(Person.role) #查看人的role属性 print(Person.walk) #引用人的走路方法,注意,这里不是在调用
实例化
实例化:类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特征
实例化的过程就是类——>对象的过程
原本我们只有一个Person类,在这个过程中,产生了一个egg对象,有自己具体的名字、攻击力和生命值。
语法:对象名 = 类名(参数)
egg = Person('egon') #类名()就等于在执行Person.__init__() #执行完__init__()就会返回一个对象。这个对象类似一个字典,存着属于这个人本身的一些属性和方法。 #你可以偷偷的理解:egg = {'name':'egon','walk':walk}
对象查看属性&调用方法
print(egg.name) #查看属性直接 对象名.属性名 print(egg.walk()) #调用方法,对象名.方法名()
关于self
self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字,但是正常人都不会这么做。
类属性的补充
一:我们定义的类的属性到底存到哪里了?有两种方式查看 dir(类名):查出的是一个名字列表 类名.__dict__:查出的是一个字典,key为属性名,value为属性值,当前类的命名空间中的方法和属性{"方法名":方法的内存地址,"属性":属性值,"_类名__属性名":属性值或者方法地址(注意:内置的在类名前面加一个下划线)})二:特殊的类属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中)
对象的相关知识
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
View Code
对象是关于类而实际存在的一个例子,即实例
对象/实例只有一种作用:属性引用
egg = Person('egon',10,1000) print(egg.name) print(egg.aggressivity) print(egg.life_value)
当然了,你也可以引用一个方法,因为方法也是一个属性,只不过是一个类似函数的属性,我们也管它叫动态属性。
引用动态属性并不是执行这个方法,要想调用方法和调用函数是一样的,都需要在后面加上括号
print(egg.attack())
面向对象小结——定义及调用的固定模式
class 类名:def __init__(self,参数1,参数2):self.对象的属性1 = 参数1self.对象的属性2 = 参数2def 方法名(self):passdef 方法名2(self):pass对象名 = 类名(1,2) #对象就是实例,代表一个具体的东西#类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法#括号里传参数,参数不需要传self,其他与init中的形参一一对应#结果返回一个对象 对象名.对象的属性1 #查看对象的属性,直接用 对象名.属性名 即可 对象名.方法名() #调用类中的方法,直接用 对象名.方法名() 即可
View Code
类命名空间与对象、实例的命名空间
创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性
而类有两种属性:静态属性和动态属性
- 静态属性就是直接在类中定义的变量
- 动态属性就是定义在类中的方法
静态属
其中类的数据属性是共享给所有对象的
>>>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,找不到则去类中找,类也找不到就找父类...最后都找不到就抛出异常
面向对象的组合用法
软件中重用的重要方式除了继承之外还有另外一种方式,即:组合
组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合
class Weapon:def prick(self, obj): # 这是该装备的主动技能,扎死对方obj.life_value -= 500 # 假设攻击力是500class Person: # 定义一个人类role = 'person' # 人的角色属性都是人def __init__(self, name):self.name = name # 每一个角色都有自己的昵称;self.weapon = Weapon() # 给角色绑定一个武器; egg = Person('egon') egg.weapon.prick() #egg组合了一个武器的对象,可以直接egg.weapon来使用组合类中的所有方法
使用组合计算圆环
#圆环是由两个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。 #这个时候,我们就首先实现一个圆形类,计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用 from math import piclass Circle:'''定义了一个圆形类;提供计算面积(area)和周长(perimeter)的方法'''def __init__(self,radius):self.radius = radiusdef area(self):return pi * self.radius * self.radiusdef perimeter(self):return 2 * pi *self.radiuscircle = 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
用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python课程
class BirthDate:def __init__(self,year,month,day):self.year=yearself.month=monthself.day=dayclass Couse:def __init__(self,name,price,period):self.name=nameself.price=priceself.period=periodclass Teacher:def __init__(self,name,gender,birth,course):self.name=name self.gender=genderself.birth=birthself.course=coursedef 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
当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好
面向对象的三大特性
继承
什么是继承
继承是另外一个懒惰(褒义)的行为。比如说有个Shape类,可以在屏幕上画出指定的形状,现在需要创建一个叫做Rectang的类,他不但可以在屏幕上画出指定的形状,而且还能计算该形状的面积。但又不想把Shape里面已经写好的draw方法再写一次。那么怎么办? 可以让Rectang从Shape类继承方法。在Rectang上调用draw方法时,程序自动从Shape调用方法。
新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类
python中类的继承分为:单继承和多继承
class ParentClass1: #定义父类passclass ParentClass2: #定义父类passclass SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClasspassclass SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类pass
查看继承
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类 (<class '__main__.ParentClass1'>,) >>> SubClass2.__bases__ (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。
>>> ParentClass1.__bases__ (<class 'object'>,) >>> ParentClass2.__bases__ (<class 'object'>,)
继承与抽象(先抽象再继承)
抽象即抽取类似或者说比较像的部分。抽象分成两个层次: 1.将奥巴马和梅西这俩对象比较像的部分抽取成类; 2.将人,猪,狗这三个类比较像的部分抽取成父类。抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类
继承抽象的理解
继承之重用性
==========================第一部分 例如猫可以:喵喵叫、吃、喝、拉、撒狗可以:汪汪叫、吃、喝、拉、撒如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,伪代码如下:#猫和狗有大量相同的内容 class 猫:def 喵喵叫(self):print '喵喵叫'def 吃(self):# do somethingdef 喝(self):# do somethingdef 拉(self):# do somethingdef 撒(self):# do somethingclass 狗:def 汪汪叫(self):print '汪汪叫'def 吃(self):# do somethingdef 喝(self):# do somethingdef 拉(self):# do somethingdef 撒(self):# do something==========================第二部分 上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:动物:吃、喝、拉、撒猫:喵喵叫(猫继承动物的功能)狗:汪汪叫(狗继承动物的功能)伪代码如下: class 动物:def 吃(self):# do somethingdef 喝(self):# do somethingdef 拉(self):# do somethingdef 撒(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 = nameself.breed = '猫'def cry(self):print('喵喵叫')class Dog(Animal):def __init__(self, name):self.name = nameself.breed='狗'def cry(self):print('汪汪叫')# ######### 执行 #########c1 = Cat('小白家的小黑猫') c1.eat()c2 = Cat('小黑的小白猫') c2.drink()d1 = Dog('胖子家的小瘦狗') d1.eat()使用继承来重用代码比较好的例子使用继承来解决代码重用的例子
使用继承来解决代码重用的例子
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):passclass Person(Animal):passegg = Person('egon',10,1000) ha2 = Dog('二愣子',50,1000) egg.eat() ha2.eat()
View Code
提示:用已经有的类建立一个新的类,这样就重用了已经有的软件中的一部分设置大部分,大大生了编程工作量,这就是常说的软件重用,不仅可以重用自己的类,也可以继承别人的,比如标准库,来定制新的数据类型,这样就是大大缩短了软件开发周期,对大型软件开发来说,意义重大.
派生
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。
示例
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.aggressivityclass Person(Animal):'''人类,继承Animal'''def attack(self, dog):'''派生:人有攻击的技能:param dog: '''dog.life_value -= self.aggressivityegg = Person('egon',10,1000) ha2 = Dog('二愣子',50,1000) print(ha2.life_value) print(egg.attack(ha2)) print(ha2.life_value)
View Code
注意:对象的属性引用,会先从实例中找l然后去类中找,然后再去父类中找...直到最顶级的父类。
在python3中,子类执行父类的方法也可以直接用super方法.
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()
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.aggressivitydef 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.aggressivitydef 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()
View Code
通过继承建立了派生类与基类之间的关系,它是一种'是'的关系,比如白马是马,人是动物。
当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好,比如教授是老师
>>> 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
View Code
接口类
继承有两种用途:
一:继承基类的方法,并且做出自己的改变或者扩展(代码重用)
二:声明某个子类兼容于某基类,定义一个接口类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)
View Code
开发中容易出现的问题
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) #执行会报错
View Code
接口初成:手动报异常:NotImplementedError来解决开发中遇到的问题
class Payment:def pay(self):raise NotImplementedErrorclass Wechatpay(Payment):def fuqian(self,money):print('微信支付了%s元'%money)p = Wechatpay() #这里不报错 pay(p,200) #这里报错了
View Code
借用abc模块来实现接口
from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta):@abstractmethoddef pay(self,money):passclass Wechatpay(Payment):def fuqian(self,money):print('微信支付了%s元'%money)p = Wechatpay() #不调就报错了
View Code
实践中,继承的第一种含义意义并不很大,甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样,所有东西都可以当文件处理,不必关心它是内存、磁盘、网络还是屏幕(当然,对底层设计者,当然也可以区分出“字符设备”和“块设备”,然后做出针对性的设计:细致到什么程度,视需求而定)。
依赖倒置原则: 高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该应该依赖细节;细节应该依赖抽象。换言之,要针对接口编程,而不是针对实现编程
在python中根本就没有一个叫做interface的关键字,上面的代码只是看起来像接口,其实并没有起到接口的作用,子类完全可以不用去实现接口 ,如果非要去模仿接口的概念,可以借助第三方模块:
http://pypi.python.org/pypi/zope.interface
twisted的twisted\internet\interface.py里使用zope.interface
文档https://zopeinterface.readthedocs.io/en/latest/
设计模式:https://github.com/faif/python-patterns
接口提取了一群类共同的函数,可以把接口当做一个函数的集合。然后让子类去实现接口中的函数。这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样
为何要用接口
理解:接口类,是用来规范子类,每个类方法是一致的,使用者在调用时,无需关心对象的类是什么,方便使用
抽象类
什么是抽象类
与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化
为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类就是从一堆类中抽取相同的内容而来的,内容包括数据属性和函数属性。
比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。
从实现角度来看,抽象类与普通类的不同之处在于:抽象类中有抽象方法,该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案
在python中实现抽象类
#一切皆文件 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.多继承问题
继承抽象类:避免多继承;
继承接口:鼓励多继承接口
接口隔离原则: 使用多个专门的接口,而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。
2.方法的实现
在抽象类中,我们可以对一些抽象方法做出基础实现;
而在接口类中,任何方法都只是一种规范,具体的功能需要子类实现
钻石继承
继承顺序
class A(object):def test(self):print('from A')class B(A):def test(self):print('from B')class C(A):def test(self):print('from C')class D(B):def test(self):print('from D')class E(C):def test(self):print('from E')class F(D,E):# def test(self):# print('from F')pass f1=F() f1.test() print(F.__mro__) #只有新式才有这个属性可以查看线性列表,经典类没有这个属性#新式类继承顺序:F->D->B->E->C->A #经典类继承顺序:F->D->B->A->E->C #python3中统一都是新式类 #pyhon2中才分新式类与经典类
继承顺序
继承原理
python到底是如何实现继承的,对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表,例如
>>> F.mro() #等同于F.__mro__ [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
继承小结
继承的作用
减少代码的重用 提高代码可读性 规范编程模式
几个名词
抽象:抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。 继承:子类继承了父类的方法和属性 派生:子类在父类方法和属性的基础上产生了新的方法和属性
抽象类与接口类
1.多继承问题 在继承抽象类的过程中,我们应该尽量避免多继承; 而在继承接口的时候,我们反而鼓励你来多继承接口2.方法的实现 在抽象类中,我们可以对一些抽象方法做出基础实现; 而在接口类中,任何方法都只是一种规范,具体的功能需要子类实现
钻石继承
新式类:广度优先 经典类:深度优先
多态
术语多态来自希腊语,意思是“有多种形式”。多态意味着就算不知道变量引用的对象类型是什么,还是能对他进行操作,而它也会根据对象(或类)类型的不同表现出不同的行为。
多态和方法
程序得到一个对象,不知道他是怎么实现的——它可能有多种“形状”。绑定到对象特性上面的函数称为方法(method)。我们已经见过字符串、列表和字典的方法。实际上多态已经出现过:
>>> "abc".count("a") 1 >>> [1,2,3,"a"].count("a") 1 >>>
对于变量x来说,不需要知道他是字符串还是列表,就可以调用count方法——不管噶是什么类型(只要你提供了一个字符串作为参数即可)。可称为多态性:指在不考虑实例类型的情况下使用实例
多态的多种形式
任何不知道对象到底是什么类型,但是又要对对象“做点什么”的时候,都会用到多态。这不仅限于方法——很多内建运算符和函数都有多态的性质,考虑下面这个列子:
peo=People() dog=Dog() pig=Pig()#peo、dog、pig都是动物,只要是动物肯定有talk方法 #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用 peo.talk() dog.talk() pig.talk()#更进一步,我们可以定义一个统一的接口来使用 def func(obj):obj.talk()
View Code
>>> 1+2 3 >>> "Fish"+"license" 'Fishlicense' >>>
这里的加运算符对于数字(本例中为整数)和字符串(以及其他类型的序列)都能起作用。
为说明这一点,假设有个叫做add的函数,他可以将两个对象相加。那么可以直接将其定义成上面的形式(功能等同但比operateor模块中的add函数效率低)
def add(x,y):return x+y
对于很多类型的参数都可以使用:
>>> add(1,2) 3 >>> add("Fish","license") 'Fishlicense' >>>
唯一能够毁掉多态的就是使用函数显示地检查类型,比如type, isinstance 以及 issubclass函数等,避免使用这种方法。
动物有多种形态:人,狗,猪 import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethoddef talk(self):passclass 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.abstractmethoddef click(self):passclass Text(File): #文件的形态之一:文本文件def click(self):print('open file')class ExeFile(File): #文件的形态之二:可执行文件def click(self):print('execute file')
View Code
鸭子类型
这个词出资俗语“如果它像鸭子一样呱呱大叫”,
python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。
例1:利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法
例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系
#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用 class TxtFile:def read(self):passdef write(self):passclass DiskFile:def read(self):passdef write(self):pass
View Code
封装
【封装】
隐藏对象的属性和实现细节,仅对外提供公共访问方式。
【好处】
1. 将变化隔离;
2. 便于使用;
3. 提高复用性;
4. 提高安全性;
【封装原则】
1. 将不需要对外提供的内容都隐藏起来;
2. 把属性都隐藏,提供公共方法对其访问。
封装不等同于多态。多态可以让用户对于不知道是什么类(或对象类型)进行方法调用,二疯子是可以不用关心对象是如何构建的而直接进行使用。
私有变量和私有方法
在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)
私有变量
#其实这仅仅这是一种变形操作 #类中所有双下划线开头的名称如__x都会自动变形成:_类名__x的形式:class A:__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__Ndef __init__(self):self.__X=10 #变形为self._A__Xdef __foo(self): #变形为_A__fooprint('from A')def bar(self):self.__foo() #只有在类内部才可以通过__foo的形式访问到.#A._A__N是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形
这种变形需要注意的问题是:
1.这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N
2.变形的过程只在类的内部生效,在定义后的赋值操作,不会变形
私有方法
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
View Code
这种自动变形的特点:
1.类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果。
2.这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。
封装与扩展性
封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说,只要接口这个基础约定不变,则代码改变不足为虑。
#类的设计者 class Room:def __init__(self,name,owner,width,length,high):self.name=nameself.owner=ownerself.__width=widthself.__length=lengthself.__high=highdef 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=nameself.owner=ownerself.__width=widthself.__length=lengthself.__high=highdef tell_area(self): #对外提供的接口,隐藏内部实现,此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法,但是功能已经变了return self.__width * self.__length * self.__high#对于仍然在使用tell_area接口的人来说,根本无需改动自己的代码,就可以用上新功能 >>> r1.tell_area()
View Code
类和对象在内存中是如何保存?
类以及类中的方法在内存中只有一份,而根据类创建的每一个对象都在内存中需要存一份,大致如下图
如上图所示,根据类创建对象时,对象中除了封装 name 和 age 的值之外,还会保存一个类对象指针,该值指向当前对象的类。
当通过 obj1 执行 【方法一】 时,过程如下:
- 根据当前对象中的 类对象指针 找到类中的方法
- 将对象 obj1 当作参数传给 方法的第一个参数 self
面向对象常用术语
抽象/实现
抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。
对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。
封装/接口
封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。
注意:封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”
真正的封装是,经过深入的思考,做出良好的抽象,给出“完整且最小”的接口,并使得内部细节可以对外透明
(注意:对外透明的意思是,外部调用者可以顺利的得到自己想要的任何功能,完全意识不到内部细节的存在)
合成
合成扩充了对类的 述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。
派生/继承/继承结构
派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。
继承描述了子类属性从祖先类继承这样一种方式
继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。
泛化/特化
基于继承
泛化表示所有子类与其父类及祖先类有一样的特点。
特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。
多态与多态性
多态指的是同一种事物的多种状态:水这种事物有多种不同的状态:冰,水蒸气
多态性的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。
冰,水蒸气,都继承于水,它们都有一个同名的方法就是变成云,但是冰.变云(),与水蒸气.变云()是截然不同的过程,虽然调用的方法都一样
自省/反射
自省也称作反射,这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__
面向对象的软件开发
很多人在学完了python的class机制之后,遇到一个生产中的问题,还是会懵逼,这其实太正常了,因为任何程序的开发都是先设计后编程,python的class机制只不过是一种编程方式,如果你硬要拿着class去和你的问题死磕,变得更加懵逼都是分分钟的事,在以前,软件的开发相对简单,从任务的分析到编写程序,再到程序的调试,可以由一个人或一个小组去完成。但是随着软件规模的迅速增大,软件任意面临的问题十分复杂,需要考虑的因素太多,在一个软件中所产生的错误和隐藏的错误、未知的错误可能达到惊人的程度,这也不是在设计阶段就完全解决的。
所以软件的开发其实一整套规范,我们所学的只是其中的一小部分,一个完整的开发过程,需要明确每个阶段的任务,在保证一个阶段正确的前提下再进行下一个阶段的工作,称之为软件工程
面向对象的软件工程包括下面几个部:
1.面向对象分析(object oriented analysis ,OOA)
软件工程中的系统分析阶段,要求分析员和用户结合在一起,对用户的需求做出精确的分析和明确的表述,从大的方面解析软件系统应该做什么,而不是怎么去做。面向对象的分析要按照面向对象的概念和方法,在对任务的分析中,从客观存在的事物和事物之间的关系,贵南出有关的对象(对象的‘特征’和‘技能’)以及对象之间的联系,并将具有相同属性和行为的对象用一个类class来标识。
建立一个能反映这是工作情况的需求模型,此时的模型是粗略的。
2 面向对象设计(object oriented design,OOD)
根据面向对象分析阶段形成的需求模型,对每一部分分别进行具体的设计。
首先是类的设计,类的设计可能包含多个层次(利用继承与派生机制)。然后以这些类为基础提出程序设计的思路和方法,包括对算法的设计。
在设计阶段并不牵涉任何一门具体的计算机语言,而是用一种更通用的描述工具(如伪代码或流程图)来描述
3 面向对象编程(object oriented programming,OOP)
根据面向对象设计的结果,选择一种计算机语言把它写成程序,可以是python
4 面向对象测试(object oriented test,OOT)
在写好程序后交给用户使用前,必须对程序进行严格的测试,测试的目的是发现程序中的错误并修正它。
面向对的测试是用面向对象的方法进行测试,以类作为测试的基本单元。
5 面向对象维护(object oriendted soft maintenance,OOSM)
正如对任何产品都需要进行售后服务和维护一样,软件在使用时也会出现一些问题,或者软件商想改进软件的性能,这就需要修改程序。
由于使用了面向对象的方法开发程序,使用程序的维护比较容易。
因为对象的封装性,修改一个对象对其他的对象影响很小,利用面向对象的方法维护程序,大大提高了软件维护的效率,可扩展性高。
在面向对象方法中,最早发展的肯定是面向对象编程(OOP),那时OOA和OOD都还没有发展起来,因此程序设计者为了写出面向对象的程序,还必须深入到分析和设计领域,尤其是设计领域,那时的OOP实际上包含了现在的OOD和OOP两个阶段,这对程序设计者要求比较高,许多人感到很难掌握。
现在设计一个大的软件,是严格按照面向对象软件工程的5个阶段进行的,这个5个阶段的工作不是由一个人从头到尾完成的,而是由不同的人分别完成,这样OOP阶段的任务就比较简单了。程序编写者只需要根据OOd提出的思路,用面向对象语言编写出程序既可。
转载于:https://www.cnblogs.com/huyangblog/p/8366520.html
Python---面向对象(一)相关推荐
- python面向对象的优点_Python面向对象编程——总结面向对象的优点
Python面向对象编程--总结面向对象的优点 一.从代码级别看面向对象 1.在没有学习类这个概念时,数据与功能是分离的 def exc1(host,port,db,charset): conn=co ...
- 这可能是Python面向对象编程的最佳实践
作者 | 崔庆才 来源 | 进击的Coder(ID:FightingCoder) Python 是支持面向对象的,很多情况下使用面向对象编程会使得代码更加容易扩展,并且可维护性更高,但是如果你写的多了 ...
- 第八课.Python面向对象(二)
类的继承和多态 继承和多态与函数有共同的目的,都是为了减少代码的冗余,提高复用的效率: 根据"Python面向对象(一)"的笔记,我现在定义一个Cinema类: #父类 class ...
- Python面向对象编程:类继承和其衍生术语
Python面向对象编程03:类继承和其衍生术语 前面我们讲到过正则表达式字符等,上一篇分享了面向对象编程和类的结构,最后稍微提到了继承. Python面向对象编程:深度认识类class_ Pytho ...
- 《Python面向对象编程指南》——1.2 基类中的__init__()方法
本节书摘来自异步社区<Python面向对象编程指南>一书中的第1章,第1.2节,作者[美]Steven F. Lott, 张心韬 兰亮 译,更多章节内容可以访问云栖社区"异步社区 ...
- Python 面向对象 基础
编程范式概述: 面向过程 和 面向对象 以及函数式编程 面向过程:(Procedure Oriented)是一种以事件为中心的编程思想. 就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实 ...
- python面向对象类属性_python面向对象之类属性和类方法案例分析
本文实例讲述了python面向对象之类属性和类方法.分享给大家供大家参考,具体如下: 目标 类的结构 类属性和实例属性 类方法和静态方法 01. 类的结构 1.1 术语 -- 实例 使用面相对象开发, ...
- 关于python面向对象编程中、下列说法中_关于Python面向对象编程的知识点总结
前言 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程. 接下来我们 ...
- python对象编程例子-这是我见过最详细的Python面向对象编程!建议收藏!
原标题:这是我见过最详细的Python面向对象编程!建议收藏! 面向对象编程和函数式编程(面向过程编程)都是程序设计的方法,不过稍有区别. 面向过程编程: 1. 导入各种外部库 2. 设计各种全局变量 ...
- python面向对象编程的优点-Python面向对象编程——总结面向对象的优点
Python面向对象编程--总结面向对象的优点 一.从代码级别看面向对象 1.在没有学习类这个概念时,数据与功能是分离的 def exc1(host,port,db,charset): conn=co ...
最新文章
- 改善C#程序的建议5:引用类型赋值为null与加速垃圾回收
- struts iterator 标签 之 indexId
- TensorFlow版的“Hello World”,运行官网第一个例子
- k8s插件说明:CoreDNS、Ingress Controller、Federation、Prometheus、ELK
- vs里根据json快速创建对应类的方法
- NG RouteReuseStrategy(路由复用策略)
- BZOJ 2754: [SCOI2012]喵星球上的点名
- Android 要收费、闭源恐难于上青天
- 你遇到过最尴尬的糗事是什么?
- Chrome中使用showModalDialog无法接收返回值,解决方案
- Java 库 Failsafe 2.0 发布,支持组合弹性策略
- 微信小程相对图片路径_微信小程序加载本地图片时“../”的使用
- Frequent values POJ - 3368(线段树)
- Java开发关键技术
- 书香小说APP界面设计
- 机器学习实战:意大利Covid-19病毒感染数学模型及预测
- 将数字转化为字符串的两种方法
- spring session Session().removeAttribute 异常
- MySQL(数据类型)
- 自动批量日文翻译工具,免费日文等小语种翻译互译工具
热门文章
- 美丽联合与腾讯云签署战略协议 全面借助腾讯云打造智慧时尚电商平台
- 云原生的本质_什么是云原生?云原生和传统软件有什么区别?有什么特征
- VMware16虚拟机怎么共享文件夹?
- java获取本地mac地址
- Java Log4j日志简单配置
- polycom安卓手机客户端_Spark,安卓上最好用的邮件客户端来了!附App下载
- php验证码只有图片没有文字_有没有免费好用的图片文字识别工具?在线就能使用超准确...
- 华为哪款手表支持鸿蒙,华为Watch 3最早或于5月发布 采用鸿蒙系统并支持eSIM
- JDK8新特性(十四)之日期时间API
- android+大富翁+局域网,【图片】大富翁6局域网(LAN)多人联机教程(求精)_大富翁吧_百度贴吧...