python面向对象的特征_python面向对象的三大特性

继承

继承是一种创建新类的方式&＃xff0c;在python中&＃xff0c;新建的类可以继承一个或多个父类&＃xff0c;父类又可称为基类或超类&＃xff0c;新建的类称为派生类或子类。

class A():pass #父类&＃xff0c;基类&＃xff0c;超类

class B:pass #父类&＃xff0c;基类&＃xff0c;超类

class C(A,B):pass #子类&＃xff0c;派生类

class D(A):pass #子类&＃xff0c;派生类

# 一个类 可以被多个类继承

# 一个类 可以继承多个父类——python里

__bases__查看所有继承的父类

__bases__则是查看所有继承的父类

print(A.__bases__)

(,)print(C.__bases__)

(, )

python3 只存在新式类

没有继承父类时默认继承object&＃xff0c;object是所有python类的基类&＃xff0c;它提供了一些常见方法&＃xff08;如__str__&＃xff09;的实现。

继承与抽象&＃xff08;先抽象再继承&＃xff09;

抽象即抽取类似或者说比较像的部分。

抽象分成两个层次&＃xff1a;

1.将奥巴马和梅西这俩对象比较像的部分抽取成类&＃xff1b;

2.将人&＃xff0c;猪&＃xff0c;狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别&＃xff08;可以隔离关注点&＃xff0c;降低复杂度&＃xff09;

继承&＃xff1a;是基于抽象的结果&＃xff0c;通过编程语言去实现它&＃xff0c;肯定是先经历抽象这个过程&＃xff0c;才能通过继承的方式去表达出抽象的结构。

&＃xff08;子类 是 父类&＃xff09;

抽象只是分析和设计的过程中&＃xff0c;一个动作或者说一种技巧&＃xff0c;通过抽象可以得到类。

函数名的重用

classAnimal:def __init__(self,name,aggr,hp):

self.name&＃61;name

self.aggr&＃61;aggr

self.hp&＃61;hp

self.func()deffunc(self):print(123)#classDog(Animal):deffunc(self):print(456)defbite(self,person):

person.hp-&＃61;self.aggr

d&＃61;Dog()#--> 456

只要是子类的对象调用&＃xff0c;子类中有的名字 一定用子类的

在子类中&＃xff0c;新建的重名的函数属性&＃xff0c;在编辑函数内功能的时候&＃xff0c;有可能需要重用父类中重名的那个函数功能&＃xff0c;应该是用调用普通函数的方式&＃xff0c;

即&＃xff1a;类名.func()&＃xff0c;此时就与调用普通函数无异了&＃xff0c;因此即便是self参数也要为其传值.

classAnimal:def __init__(self,name,aggr,hp):

self.name&＃61;name

self.aggr&＃61;aggr

self.hp&＃61;hpdefeat(self):print(&＃39;吃药回血&＃39;)

self.hp&＃43;&＃61;100

classDog(Animal):def __init__(self,name,aggr,hp,kind):

Animal.__init__(self,name,aggr,hp) # self.kind &＃61; kind #派生属性

defeat(self):

Animal.eat(self)#如果既想实现新的功能也想使用父类原本的功能&＃xff0c;还需要在子类中再调用父类

self.teeth &＃61; 2

def bite(self,person): #派生方法

person.hp -&＃61; self.aggr

在python3中&＃xff0c;子类执行父类的方法也可以直接用super方法.&＃xff08;super只在python中存在&＃xff09;

classDog(Animal):def __init__(self,name,aggr,hp,kind):

super().__init__(name,aggr,hp) #只在新式类中有&＃xff0c;python3中所有类都是新式类

#super(Animal,self).__init__(name,aggr,hp)

#Animal.eat(self)

self.kind &＃61; kind #派生属性

def eat(self):print(&＃39;dog eating&＃39;)

jin&＃61; Dog(&＃39;金老板&＃39;,200,500,&＃39;teddy&＃39;)print(jin.name)

jin.eat()

super(Dog,jin).eat()

小结

父类中没有的属性 在子类中出现 叫做派生属性

父类中没有的方法 在子类中出现 叫做派生方法

只要是子类的对象调用&＃xff0c;子类中有的名字 一定用子类的&＃xff0c;子类中没有才找父类的&＃xff0c;如果父类也没有报错#如果父类、子类都有&＃xff0c;用子类的。

#如果还想用父类的&＃xff0c;单独调用父类的:

#父类名.方法名 需要自己传self参数

#super().方法名 不需要自己传self

正常的代码中 单继承 &＃61;&＃61;&＃61;减少了代码的重复

继承表达的是一种 子类 是 父类的关系

多继承

单继承 &＃xff1a; 子类有的用子类 &＃xff0c;子类没有用父类。

多继承中&＃xff0c;我们子类的对象调用一个方法&＃xff0c;默认是就近原则&＃xff0c;找的顺序是什么&＃xff1f;

classF:def func(self): print(&＃39;F&＃39;)class A(F):pass

#def func(self): print(&＃39;A&＃39;)

classB(A):pass

#def func(self): print(&＃39;B&＃39;)

class E(F):pass

#def func(self): print(&＃39;E&＃39;)

classC(E):pass

#def func(self): print(&＃39;C&＃39;)

classD(B,C):pass

#def func(self):print(&＃39;D&＃39;)

d&＃61;D()#d.func()

python2.7 新式类和经典类共存&＃xff0c;新式类要继承object

python3 只有新式类&＃xff0c;默认继承object

经典类中 ,深度优先

新式类中 ,广度优先

经典类和新式类还有一个区别 mro方法只在新式类中存在

super 只在python3中存在

super的本质 &＃xff1a;不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

classA(object):def func(self): print(&＃39;A&＃39;)classB(A):deffunc(self):

super().func()print(&＃39;B&＃39;)classC(A):deffunc(self):

super().func()print(&＃39;C&＃39;)classD(B,C):deffunc(self):

super().func()print(&＃39;D&＃39;)

b&＃61;D()

b.func()print(B.mro())#[, , ]

钻石问题

新式类 &＃xff1a; 顺序如图所示&＃xff0c;以根节点D为依据&＃xff0c;在保证每个类里的函数都能取到的基础上&＃xff0c;广度优先。

经典类&＃xff1a;深度优先 图1 B->A 　　图2 dbafce(不再走f&＃xff0c;因为之前走过) 　　图3 dbace

小结

继承 &＃xff1a; 什么是什么的关系(子类是父类)

单继承*****先抽象再继承&＃xff0c;几个类之间的相同代码抽象出来&＃xff0c;成为父类

子类自己没有的名字&＃xff0c;就可以使用父类的方法和属性

如果子类自己有&＃xff0c;一定是先用自己的

在类中使用self的时候&＃xff0c;一定要看清楚self指向谁

多继承***新式类和经典类&＃xff1a;

多继承寻找名字的顺序 &＃xff1a; 新式类广度优先&＃xff0c;经典类深度优先

新式类中 有一个类名.mro方法&＃xff0c;查看广度优先的继承顺序

python3中 有一个super方法&＃xff0c;根据广度优先的继承顺序查找上一个类

抽象类和接口类

java &＃xff1a; 面向对象编程

设计模式 —— 接口

接口类 &＃xff1a; python原生不支持(只是一种思想)

抽象类 &＃xff1a; python原生支持的

classWechat(Payment):

def pay(self,money):

print(&＃39;已经用微信支付了%s元&＃39;%money)classAlipay(Payment):

def pay(self,money):

print(&＃39;已经用支付宝支付了%s元&＃39; %money)classApplepay(Payment):

def pay(self,money):

print(&＃39;已经用applepay支付了%s元&＃39; %money)

def pay(pay_obj,money): # 统一支付入口

pay_obj.pay(money)

w&＃61;Wechat()

ap&＃61;Apple()

# a&＃61; Ali() #TypeError: Can&＃39;t instantiate abstract class Ali with abstract methods pay

# pay(w,100) #微信支付了100

# pay(ap,100) #苹果支付了100

# pay(a,100)

p&＃61; Payment() #Can&＃39;t instantiate abstract class Payment with abstract methods pay 不能创建

接口类的多继承问题

接口隔离原则

使用多个专门&＃xff08;Fly_Animal、Walk_Animal等&＃xff09;的接口&＃xff0c;而不使用单一&＃xff08;Animal&＃xff09;的总接口。即客户端不应该依赖那些不需要的接口。

fromabc import abstractmethod,ABCMetaclass Swim_Animal(metaclass&＃61;ABCMeta):

&＃64;abstractmethod

def swim(self):passclass Walk_Animal(metaclass&＃61;ABCMeta):

&＃64;abstractmethod

def walk(self):passclass Fly_Animal(metaclass&＃61;ABCMeta):

&＃64;abstractmethod

def fly(self):passclassTiger(Walk_Animal,Swim_Animal):

def walk(self):

pass

def swim(self):

passclassOldYing(Fly_Animal,Walk_Animal):passclass Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass

View Code

抽象类 &＃xff1a;

规范

一般情况下 单继承 能实现的功能都是一样的&＃xff0c;所以在父类中可以有一些简单的基础实现

多继承的情况 由于功能比较复杂&＃xff0c;所以不容易抽象出相同的功能的具体实现写在父类中

抽象类还是接口类 &＃xff1a; 面向对象的开发规范 所有的接口类和抽象类都不能实例化

java &＃xff1a;

java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题

但对于多继承的需求&＃xff0c;由于java本身语法的不支持&＃xff0c;所以创建了接口Interface这个概念来解决多继承的规范问题

python

python中没有接口类 &＃xff1a;

python中自带多继承 所以我们直接用class来实现了接口类

python中支持抽象类 &＃xff1a; 一般情况下 单继承 不能实例化

且可以实现python代码

#一切皆文件

import abc #利用abc模块实现抽象类

class All_file(metaclass&＃61;abc.ABCMeta):

all_type&＃61;&＃39;file&＃39;&＃64;abc.abstractmethod#定义抽象方法&＃xff0c;无需实现功能

defread(self):&＃39;子类必须定义读功能&＃39;with open(&＃39;filaname&＃39;) as f:pass&＃64;abc.abstractmethod#定义抽象方法&＃xff0c;无需实现功能

defwrite(self):&＃39;子类必须定义写功能&＃39;

pass

class Txt(All_file): #子类继承抽象类&＃xff0c;但是必须定义read和write方法

defread(self):print(&＃39;文本数据的读取方法&＃39;)defwrite(self):print(&＃39;文本数据的读取方法&＃39;)class Sata(All_file): #子类继承抽象类&＃xff0c;但是必须定义read和write方法

defread(self):print(&＃39;硬盘数据的读取方法&＃39;)defwrite(self):print(&＃39;硬盘数据的读取方法&＃39;)class Process(All_file): #子类继承抽象类&＃xff0c;但是必须定义read和write方法

defread(self):print(&＃39;进程数据的读取方法&＃39;)defwrite(self):print(&＃39;进程数据的读取方法&＃39;)

wenbenwenjian&＃61;Txt()

yingpanwenjian&＃61;Sata()

jinchengwenjian&＃61;Process()#这样大家都是被归一化了,也就是一切皆文件的思想

wenbenwenjian.read()

yingpanwenjian.write()

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

View Code

什么是多态

多态 python 天生支持多态&＃xff0c;python 动态强类型的语言

鸭子类型

不崇尚根据继承所得来的相似

我只是自己实现我自己的代码就可以了。

如果两个类刚好相似&＃xff0c;并不产生父类的子类的兄弟关系&＃xff0c;而是鸭子类型

list tuple 这种相似&＃xff0c;是自己写代码的时候约束的&＃xff0c;而不是通过父类约束的

classList():def __len__(self):pass

classTuple():def __len__(self):pass

deflen(obj):return obj.__len__()

l&＃61;Tuple()

len(l)

优点 &＃xff1a; 松耦合 每个相似的类之间都没有影响

缺点 &＃xff1a; 太随意了,只能靠自觉

封装

广义上面向对象的封装 &＃xff1a;代码的保护&＃xff0c;面向对象的思想本身就是一种

只让自己的对象能调用自己类中的方法

狭义上的封装 —— 面向对象的三大特性之一

属性 和 方法都藏起来 不让你看见

classPerson:__key &＃61; 123 #私有静态属性

def __init__(self,name,passwd):

self.name&＃61;name

self.__passwd &＃61; passwd #私有属性

def __get_pwd(self): #私有方法

return self.__passwd #只要在类的内部使用私有属性&＃xff0c;就会自动的带上_类名

def login(self): #正常的方法调用私有的方法

self.__get_pwd()

alex&＃61; Person(&＃39;alex&＃39;,&＃39;alex3714&＃39;)print(alex._Person__passwd) #_类名__属性名

print(alex.get_pwd())

所有的私有 都是在变量的左边加上双下划綫

对象的私有属性

类中的私有方法

类中的静态私有属性

所有的私有的 都不能在类的外部使用&＃xff08;自觉_person&＃xff09;

classRoom:def __init__(self,name,length,width):

self.__name &＃61;name

self.__length &＃61;length

self.__width &＃61;widthdefget_name(self):return self.__name

defset_name(self,newName):if type(newName) is str and newName.isdigit() &＃61;&＃61;False:

self.__name &＃61;newNameelse:print(&＃39;不合法的姓名&＃39;)defarea(self):return self.__length * self.__widthjin&＃61; Room(&＃39;金老板&＃39;,2,1)print(jin.area())

jin.set_name(&＃39;2&＃39;)print(jin.get_name())#假设父类的私有属性 能被 子类调用么

classFoo:__key &＃61; &＃39;123&＃39; #_Foo__key

classSon(Foo):print(Foo.__key) #_Son__key 不能

#会用到私有的这个概念de场景#1.隐藏起一个属性 不想让类的外部调用#2.我想保护这个属性&＃xff0c;不想让属性随意被改变#3.我想保护这个属性&＃xff0c;不被子类继承

接口类 抽象类

python中没有接口类&＃xff0c;有抽象类&＃xff0c;abc模块中的metaclass&＃61;ABCMeta&＃xff0c;&＃64;abstructmethod

本质是做代码规范用的&＃xff0c;希望在子类中实现和父类方法名字完全一样的方法

在java的角度上看 是有区别的

java本来就支持单继承 所以就有了抽象类

java没有多继承 所以为了接口隔离原则&＃xff0c;设计了接口这个概念&＃xff0c;支持多继承了

python及支持单继承也支持多继承&＃xff0c;所以对于接口类和抽象类的区别就不那么明显了

甚至在python中没有内置接口类

多态和鸭子类型

多态 —— python天生支持多态

鸭子类型 —— 不依赖父类的情况下实现两个相似的类中的同名方法

封装 —— 私有的

在python中只要__名字

在python中只要__名字&＃xff0c;就把这个名字私有化了

私有化了之后 就不能能从类的外部直接调用了

静态属性 方法 对象属性 都可以私有化

这种私有化只是从代码级别做了变形&＃xff0c;并没有真的约束

变形机制 _类名__名字 在类外用这个调用&＃xff0c;在类的内部直接__名字调用

小结

property

内置装饰器函数 只在面向对象中使用

#属性 查看 修改 删除

classPerson:def __init__(self,name):

self.__name &＃61;name

self.price&＃61; 20&＃64;propertydefname(self):return self.__name&＃64;name.deleterdefname(self):del self.__name&＃64;name.setterdefname(self,new_name):

self.__name &＃61;new_name

brother2&＃61; Person(&＃39;二哥&＃39;)#del Person.price

brother2.name &＃61; &＃39;newName&＃39;brother2#del brother2.name

print(brother2.name)

method 方法

staticmathod 静态的方法 ***

classmethod 类方法 ****

类的操作行为classGoods:__discount &＃61; 0.8

def __init__(self,name,price):

self.name&＃61;name

self.__price &＃61;price

&＃64;propertydefprice(self):return self.__price * Goods.__discount&＃64;classmethod#把一个方法 变成一个类中的方法&＃xff0c;这个方法就直接可以被类调用&＃xff0c;不需要依托任何对象

def change_discount(cls,new_discount): #修改折扣

cls.__discount &＃61;new_discount

apple&＃61; Goods(&＃39;苹果&＃39;,5)print(apple.price)

Goods.change_discount(0.5) #Goods.change_discount(Goods)

print(apple.price)

当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

# 在完全面向对象的程序中&＃xff0c;

# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法

classLogin:def __init__(self,name,password):

self.name&＃61;name

self.pwd&＃61;passworddef login(self):pass&＃64;staticmethoddef get_usr_pwd(): #静态方法

usr &＃61; input(&＃39;用户名 &＃xff1a;&＃39;)

pwd&＃61; input(&＃39;密码 &＃xff1a;&＃39;)

Login(usr,pwd)

Login.get_usr_pwd()

类方法和静态方法 都是类调用的。

对象可以调用类方法和静态方法&＃xff0c;一般情况下 推荐用类名调用。

类方法 有一个默认参数 cls 代表这个类 cls

静态方法 没有默认的参数 就象函数一样