Python3 面向对象
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量: 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员: 类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写: 如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
实例变量: 定义在方法中的变量,只作用于当前实例的类。
继承: 即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,素以Dog也是一个Animal。
实例化: 创建一个类的实例,类的具体对象。
方法: 类中定义的函数。
对象: 通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
和其它编程语言相比,Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
python3 类创建
面向对象编程是一种编程方式,此编程方式的落地需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。
类就是一个模板,模板里可以包含多个函数,函数里实现一些功能。
对象则是根据模板创建的实例,通过实例对象可以执行类中的函数。
#创建类
class Foo: #class是关键字(表示要开始创建类了);Foo是新建类名称
#创建类中函数
def bar(self): #self特殊参数(必填)
print('Bar')
def hello(self,name):
print('I am %s'%name)
#根据Foo创建对象obj
obj=Foo()
obj.bar() #执行bar方法
obj.hello('Amy')
**执行结果:**
Bar
I am Amy
注: 类的函数第一个参数必须是self,类中定义的函数叫做“方法”
诶,你在这里是不是有疑问了?使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便:
面向对象:【创建对象】【通过对象执行方法】
函数编程:【执行函数】
观察上述对比答案则是肯定的,然后并非绝对,场景的不同适合其的编程方式也不同。
总结:函数式的应用场景 --> 各个函数之间是独立且无共用的数据
面向对象三大特性:封装、继承、多态
一、封装
封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。
所以,在使用面向对象的封装特性时,需要:
-将内容封装到某处
-从某处调用被封装的内容
第一步:将内容封装到某处
#创建类
class Foo:
def _init_(self,name,age): #构造函数,类实例化是自动执行
#初始化实例属性
self.name=name
self.age=age
#根据类Foo创建对象
#自动执行Foo类的_init_方法
obj1=Foo('Amy',18) #Amy和18分别封装到obj1/self的name和age属性中(此处obj1其实就是self)
#根据类Foo创建对象
#自动执行Foo类的_init_方法
obj2=Foo('Python',99) #Python和99分别封装到obj2/self的name和age属性中(此处obj2其实就是self)
self 是一个形式参数,内容其实被封装到了对象 obj1 和 obj2 中,每个对象中都有 name 和 age 属性。
第二步:从某处调用被封装的内容
调用被封装的内容时,有两种情况:
-过对象直接调用
-通过self间接调用
1、通过对象直接调用被封装的内容
上面展示了对象 obj1 和 obj2 在内存中保存的方式,根据保存格式可以如此调用被封装的内容:对象.属性名
#创建类
class Foo:
def __init__(self,name,age): #构造函数,类实例化是自动执行
#初始化实例属性
self.name=name
self.age=age
obj1 = Foo('Amy',18)
print(obj1.name) #直接调用obj1对象的name属性
print(obj1.age) #直接调用obj1对象的age属性
obj2=Foo('Python',99)
print(obj2.name) #直接调用obj2对象的name属性
print(obj2.age) #直接调用obj2对象的age属性
**执行结果:**
Amy
18
Python
99
2、通过self间接调用被封装的内容
执行类中的方法时,需要通过self间接调用被封装的内容
#创建类
class Foo:
def __init__(self,name,age): #构造函数,类实例化是自动执行
#初始化实例属性
self.name=name
self.age=age
def detail(self):
print(self.name)
print(self.age)
obj1 = Foo('Amy',18)
obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的self=obj1,即:self.name 是Amy;self.age是18
obj2 = Foo('python', 99)
obj2.detail() # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的self=obj2,即:self.name是python;self.age是99
**执行结果:**
Amy
18
python
99
二、继承
继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容。
例如:
猫可以:喵喵叫、吃、喝、拉、撒
狗可以:汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,如下所示:
伪代码
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()
**执行结果:**
小白家的小黑猫 吃
小黑的小白猫 喝
胖子家的小瘦狗 吃
所以,对于面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法。
注:除了子类和父类的称谓,你可能看到过派生类和基类,他们与子类和父类只是叫法不同而已。
那么问题又来了,多继承呢?
是否可以继承多个类
如果继承的多个类每个类中都定了相同的函数,那么那一个会被使用呢?
1、Python的类可以继承多个类,Java和C#中则只能继承一个类
2、Python的类如果继承了多个类,那么其寻找方法的方式有两种,分别是:深度优先和广度优先
下图中B、C类继承D类,A类继承B、C类。
- 当类是经典类时,多继承情况下,会按照深度优先方式查找
- 当类是新式类时,多继承情况下,会按照广度优先方式查找
经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了跟多的功能,也是之后推荐的写法,从写法上区分的话,如果当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。
经典类多继承
class D:
def bar(self):
print('D.bar')
class C(D):
def bar(self):
print('C.bar')
class B(D):
def bar(self):
print('B.bar')
class A(B, C):
def bar(self):
print('A.bar')
a = A()
# 执行bar方法时
# 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去D类中找,如果D类中么有,则继续去C类中找,如果还是未找到,则报错
# 所以,查找顺序:A --> B --> D --> C
# 在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了
a.bar()
**执行结果:**
A.bar
新式类多继承
class D(object):
def bar(self):
print('D.bar')
class C(D):
def bar(self):
print('C.bar')
class B(D):
def bar(self):
print('B.bar')
class A(B, C):
def bar(self):
print('A.bar')
a = A()
# 执行bar方法时
# 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错
# 所以,查找顺序:A --> B --> C --> D
# 在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了
a.bar()
**执行结果:**
A.bar
经典类:首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去D类中找,如果D类中么有,则继续去C类中找,如果还是未找到,则报错
新式类:首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错
注意:在上述查找过程中,一旦找到,则寻找过程立即中断,便不会再继续找了
三、多态
Pyhon不支持Java和C#这一类强类型语言中多态的写法,但是原生多态,其Python崇尚“鸭子类型”。
Python伪代码实现Java或C#的多态
class F1:
pass
class S1(F1):
def show(self):
print('S1.show')
class S2(F1):
def show(self):
print('S2.show')
# 由于在Java或C#中定义函数参数时,必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类
# 而实际传入的参数是:S1对象和S2对象
def Func(F1 obj):
"""Func函数需要接收一个F1类型或者F1子类的类型"""
print(obj.show())
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj,执行 S1 的show方法,结果:S1.show
s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj,执行 Ss 的show方法,结果:S2.show
Python “鸭子类型”
class F1:
pass
class S1(F1):
def show(self):
print('S1.show')
class S2(F1):
def show(self):
print('S2.show')
def Func(obj):
print obj.show()
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
总结
以上就是本节对于面向对象初级知识的介绍,总结如下:
- 面向对象是一种编程方式,此编程方式的实现是基于对类和对象的使用
- 类是一个模板,模板中包装了多个“函数”供使用
- 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数
- 面向对象三大特性:封装、继承和多态
转载地址:https://www.cnblogs.com/chengd/articles/7287528.html