一.简介
面向过程:根据业务逻辑从上到下写垒代码
函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
面向对象:对函数进行分类和封装,让开发“更快更好更强...”
面向对象编程是一种编程方式,此编程方式的落地需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用
类就是一个模板,模板里可以包含多个函数,函数里实现一些功能
对象则是根据模板创建的实例,通过实例对象可以执行类中的函数
面向对象:【创建对象】【通过对象执行方法】
函数编程:【执行函数】
函数式的应用场景 --> 各个函数之间是独立且无共用的数据
面向对象技术简介:
类(Class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
实例变量:定义在方法中的变量,只作用于当前实例的类。
继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
实例化:创建一个类的实例,类的具体对象。
方法:类中定义的函数。
对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
1.创建类
python类使用class 关键字来创建。简单的类的声明可以是关键字后紧跟类名:
classFoo:defBar(self):print 'Bar'
defHello(self, name):print 'i am %s' %name#根据类Foo创建对象obj
obj =Foo()
obj.Bar()#执行Bar方法
obj.Hello('test') #执行Hello方法
二.面向对象特性
面向对象的三大特性是指:封装、继承和多态
1.封装
封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容
所以,在使用面向对象的封装特性时,需要:
将内容封装到某处
从某处调用被封装的内容
#!/usr/bin/env python#-*- coding:utf-8 -*-
classFoo():#__init__为构造方法,根据类创建对象时自动执行
def __init__(self,bk):
self.backend=bkdeffun1(self):print(self.backend)deffun2(self,arg):print(arg)
obj= Foo("www.test.org") #将www.test.org封装到obj的bk属性中
obj.fun2("tet")
从某处调用被封装的内容
调用被封装的内容时,有两种情况:
通过对象直接调用
通过self间接调用
classPerson():def __init__(self,name,age,weight):
self.Name=name
self.Age=age
self.Weight=weightdefeat(self):
self.Weight= self.Weight + 1
defwork(self):
self.Weight= self.Weight - 2user1= Person("lily","20",100)print(user1.Weight) #直接调用
通过self间接调用被封装的内容
#间接调用
classFoo:def __init__(self, name, age):
self.Name=name
self.Age=agedefin_call(self):"""间接调用init中的值"""
print(self.Name)print(self.Age)
obj= Foo("mary", 20)
obj.in_call()
添加,更改,删除属性
classPerson():def __init__(self, name, age, weight):
self.Name=name
self.Age=age
self.Weight=weightdefeat(self):
self.Weight= self.Weight + 1
defwork(self):
self.Weight= self.Weight - 2user1= Person("lily","20",100)#添加属性
user1.address = "BJ"
print(user1.address)#更改属性
user1.address = "China"
print(user1.address)#删除属性
del user1.address
对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容
练习
#!/usr/bin/env python#-*- coding:utf-8 -*-
classGame():def __init__(self,name,age,HP,gen):
self.Name=name
self.Age=age
self.Gender=gen
self.HP=HPdeffight(self):"""格斗
:return: 生命值"""self.HP= self.HP - 100
defpromote(self):"""提升修炼
:return: 生命值"""self.HP= self.HP + 200
defmult(self):"""多人格斗
:return: 生命值"""self.HP= self.HP - 150
defdetail(self):"""人物信息描述
:return: 人物信息"""CV= "Name: %s, Age: %d, Gender: %s,initHP: %d" %(self.Name, self.Age, self.Gender, self.HP)print(CV)#创建人物
Person1 = Game("user1", 18, 1000, "female")
Person2= Game("user2", 20, 2000, "male")
Person3= Game("user3", 17, 1500, "male")#输出人物信息
Person1.detail()
Person2.detail()
Person3.detail()#游戏
whileTrue:
Person1.fight()
Person1.detail()if Person1.HP <= 200:
chose= input("\033[33;1m 您当前的生命值已低与200是否修行提升?是:y 否:n\033[0m\n")if chose.lower() == "y":whileTrue:
Person1.detail()
Person1.promote()if Person1.HP == 1000:print("\033[33;1m 恢复初始状态!!\033[0m")break
elif chose.lower() == "n":
Person1.fight()if Person1.HP ==0:break
print("user1 has been dead!!")break
View Code
2.继承
继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容(基类,派生类)
对于面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法
#!/usr/bin/env python#-*- coding:utf-8 -*-
classFather:deffun(self):print("Father.fun")#继承基类(Father)
classSon(Father):def __init__(self):print("Son")deff(self):print("Son.f")
obj=Son()
obj.fun()#调用继承方法
#继承
classAnimals():defeat(self):print(self.Name + "eat")defdrink(self):print(self.Name + "drink")classPerson(Animals):def __init__(self, name):
self.Name=namedefthink(self):print(self.Name + "think")
obj= Person("user1")
obj.drink()
obj.eat()
obj.think()
2.2多继承
Python的类可以继承多个类,Java和C#中则只能继承一个类
Python的类如果继承了多个类,那么其寻找方法的方式有两种,分别是:深度优先和广度优先
当类是经典类时,多继承情况下,会按照深度优先方式查找
当类是新式类时,多继承情况下,会按照广度优先方式查找
#经典类(2.7版本之前)
classA:deffun(self):print("A")classB(A):def __init__(self):print("b")
obj=B()
obj.fun()
#新式类
classD(object):defbar(self):print 'D.bar'
classC(D):defbar(self):print 'C.bar'
classB(D):defbar(self):print 'B.bar'
classA(B, C):defbar(self):print 'A.bar'a=A()#执行bar方法时#首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错#所以,查找顺序:A --> B --> C --> D#在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了
a.bar()
View Code
经典类:先深度,后广度
新式类:先左后右,其次深度
如果找到匹配方法,就不会继续找下去
3.多态
classF1:pass
classS1(F1):defshow(self):print 'S1.show'
classS2(F1):defshow(self):print 'S2.show'
#由于在Java或C#中定义函数参数时,必须指定参数的类型#为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类#而实际传入的参数是:S1对象和S2对象
defFunc(F1 obj):"""Func函数需要接收一个F1类型或者F1子类的类型"""
printobj.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伪代码实现Java或C#的多态
View Code
classF1:pass
classS1(F1):defshow(self):print 'S1.show'
classS2(F1):defshow(self):print 'S2.show'
defFunc(obj):printobj.show()
s1_obj=S1()
Func(s1_obj)
s2_obj=S2()
Func(s2_obj)
Python “鸭子类型”
View Code
总结:
面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用
类 是一个模板,模板中包装了多个“函数”供使用
对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数
面向对象三大特性:封装、继承和多态