面对对象编程
1.面对对象不是所有情形都适用
1.1函数式编程
def fun1(arg1):
pass
def fun2(arg1, arg2):
pass
fun1('wuwen')
fun2('henshuai')
2.1面对对象编程
class humanBeing:
def fun1(self, arg1):
pass
def fun2(self,arg1, arg2):
pass
obj1 = humanBeing()
obj1.fun1('wuwen')
obj2.fun2('henshuai')
结论:单从代码的复杂程度来看,面对对象编程并不是适合所有情况
2.面对对象编程的格式规范:
a.定义类
class 类名:
def 方法1(self, arg)
pass
b.根据类创建对象(创建一个**类的实例)
使用对象去执行类中的方法(函数编程中,我们称之为函数),如下图为类与对象的关系
3.类的方法的默认参数self
self,形式参数,代指执行方法的对象,在python内部传递,为封装而生
class humanBeing:
def fun1(self, name):
print(self, name)
def fun2(self, name, gender):
print(self, name, gender)
obj1 = humanBeing()
print(obj1)
obj1.fun1('wuwen')
obj1.fun2('wuwen', 'female')
'''
<__main__.humanBeing object at 0x02171210>
<__main__.humanBeing object at 0x02171210> wuwen
<__main__.humanBeing object at 0x02131490> wuwen female
总结:self为实例本身的内存地址
'''
4.封装:
当每个函数里面都需要用到相同的参数(如上类方法中的name参数),我们可以提前把参数封装到对象(实例)中去
class humanBeing:
def fun1(self):
print(self.name)
def fun2(self, gender):
print(self.name, gender)
obj1 = humanBeing()
obj1.name = 'wuwen'
obj1.fun1()
'''
wuwen
'''
5.用初始化封装
类名+() ---->>> 自动执行类中的__init__方法;创建一个对象
在__init__方法中执行具体封装的操作
__init__有一个特殊名字:构造方法
__del__有一个特殊的名字:析构器
class Oldboy:
def __init__(self, backend, record):
'''
构造方法
:param backend:
:param record:
'''
# 普通字段
self.backend = backend
self.record = record
def fetch(self):
print(self.backend)
def add_record(self):
print(self.record)
def del_record(self):
print(self.record)
# 创建对象,并且封装
obj1 = Oldboy('www.oldboy.org', 'wohenshuai')
# 执行方法,执行过程中可以根据self去obj1中去取已经封装在里面的数据
obj1.fetch()
obj1.add_record()
obj1.del_record()
5.1 练习
小明,10岁,男,上山去砍柴
小明,10岁,男,开车去东北
小明,10岁,男,最爱大保健
老李,10岁,男,上山去砍柴
老李,10岁,男,开车去东北
老李,10岁,男,最爱大保健
1 def kanchai(name, age, gender): 2 print("%s,%s岁,%s,上山去砍柴" % (name, age, gender)) 3 4 5 def qudongbei(name, age, gender): 6 print("%s,%s岁,%s,开车去东北" % (name, age, gender)) 7 8 9 def dabaojian(name, age, gender): 10 print("%s,%s岁,%s,最爱大保健" % (name, age, gender)) 11 12 13 kanchai('小明', '10', '男') 14 qudongbei('小明', '10', '男') 15 dabaojian('小明', '10', '男') 16 17 kanchai('老李', '10', '男') 18 qudongbei('老李', '10', '男') 19 dabaojian('老李', '10', '男')
1 class Foo: 2 def __init__(self, name, age, gender): 3 self.name = name 4 self.age = age 5 self.gender = gender 6 7 def kanchai(self): 8 print("%s,%s岁,%s,上山去砍柴" % (self.name, self.age, self.gender)) 9 10 def qudongbei(self): 11 print("%s,%s岁,%s,开车去东北" % (self.name, self.age, self.gender)) 12 13 def dabaojian(self): 14 print("%s,%s岁,%s,最爱大保健" % (self.name, self.age, self.gender)) 15 16 17 xiaoming = Foo('小明', 10, '男') 18 xiaoming.kanchai() 19 xiaoming.qudongbei() 20 xiaoming.dabaojian() 21 22 laoli = Foo('老李', 90, '男') 23 laoli.kanchai() 24 laoli.qudongbei() 25 laoli.dabaojian()
5.2 小游戏(可以用pickle存档)
pickle可以将一个类的对象序列化
class person:
def __init__(self, name, age, weight):
self.Name = name
self.Age = age
self.Weight = weight
def chi(self):
self.Weight = self.Weight + 2
print("%s 吃" % self.Name)
def bodybuilding(self):
self.Weight = self.Weight - 1
import pickle
# pickle 可以序列化对象,json只能处理字符串,数字,字典,列表与元组
# 游戏存档
ret = pickle.load(open('cundang.log', 'rb'))
print(ret)
if ret:
print(ret.Weight)
else:
o1 = person('小明', 5, 200)
o1.bodybuilding()
o1.chi()
o1.chi()
o1.chi()
o1.chi()
o1.chi()
o1.chi()
pickle.dump(o1, open('cundang.log', 'wb')) # 将对象存档
6.继承
6.1 单继承
'''
子类继承父类所有的功能
父类不能使用子类的功能
当父类和子类同时具有某种功能时:
对于由父类创建的对象,则使用自己的功能,因为它无法继承自己的子类。
对于子类创建的的对象,我们也使用自己的功能,因为,优先级的先后。
'''
class Animals:
def chi(self):
print(self.name + '吃')
def he(self):
print(self.name + '喝')
def piao(self):
print('爱piao')
class Dog(Animals):
def __init__(self, name):
self.name = name
def wang(self):
print(self.name + '汪汪汪~')
def piao(self):
print('不爱piao')
obj1 = Dog('桃桃')
obj1.piao()
'''
不爱piao
'''
6.2 多继承(笔试易考)
#!/usr/bin env python
# -*- coding:utf-8 -*-
'''
在c++和java中,一个子类只能继承一个父类
但是在python中,一个子类可以继承多个父类
'''
class Animals:
def chi(self):
print(self.name + '吃')
def he(self):
print(self.name + '喝')
def piao(self):
print('爱piao')
class Uncle:
def du(self):
print('赌')
def piao(self):
print('很爱piao')
class Dog(Animals, Uncle):
'''
先继承Animals和Uncle父类中不重复的方法
对不重复的方法:优先找自己,其次第一个父类Animals,最后第二个父类Uncle
'''
def __init__(self, name):
self.name = name
def wang(self):
print(self.name + '汪汪汪~')
def piao(self):
print('不爱piao')
obj1 = Dog('taotao')
obj1.piao()
'''
不爱piao
'''
6.3 继承顺序
6.3.1 无共同父类
class A:
def f(self):
print('A')
class B:
def f1(self):
print('B')
class C(A):
def f(self):
print('C')
class D(B):
def f1(self):
print('D')
class E(C, D):
def f(self):
print('E')
obj1 = E()
obj1.f1()
'''
D
'''
6.3.2 有共同父类
class Top:
def f1(self):
print('Top')
class A(Top):
def f(self):
print('A')
class B(Top):
def f1(self):
print('B')
class C(A):
def f(self):
print('C')
class D(B):
def f1(self):
print('D')
class E(C, D):
def f(self):
print('E')
obj1 = E()
obj1.f1()
'''
D
'''
7.多态
Pyhon不支持Java和C#这一类强类型语言中多态的写法,但是原生多态,其Python崇尚“鸭子类型”
1 class F1: 2 pass 3 4 5 class S1(F1): 6 7 def show(self): 8 print 'S1.show' 9 10 11 class S2(F1): 12 13 def show(self): 14 print 'S2.show' 15 16 17 # 由于在Java或C#中定义函数参数时,必须指定参数的类型 18 # 为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类 19 # 而实际传入的参数是:S1对象和S2对象 20 21 def Func(F1 obj): 22 """Func函数需要接收一个F1类型或者F1子类的类型""" 23 24 print obj.show() 25 26 s1_obj = S1() 27 Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj,执行 S1 的show方法,结果:S1.show 28 29 s2_obj = S2() 30 Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj,执行 Ss 的show方法,结果:S2.show
1 class F1: 2 pass 3 4 5 class S1(F1): 6 7 def show(self): 8 print 'S1.show' 9 10 11 class S2(F1): 12 13 def show(self): 14 print 'S2.show' 15 16 def Func(obj): 17 print obj.show() 18 19 s1_obj = S1() 20 Func(s1_obj) 21 22 s2_obj = S2() 23 Func(s2_obj)
8.经典问答
问题一:什么样的代码才是面向对象?
答:从简单来说,如果程序中的所有功能都是用 类 和 对象 来实现,那么就是面向对象编程了。
问题二:函数式编程 和 面向对象 如何选择?分别在什么情况下使用?
答:须知:对于 C# 和 Java 程序员来说不存在这个问题,因为该两门语言只支持面向对象编程(不支持函数式编程)。
而对于 Python 和 PHP 等语言却同时支持两种编程方式,且函数式编程能完成的操作,面向对象都可以实现;而面
向对象的能完成的操作,函数式编程不行(函数式编程无法实现面向对象的封装功能)。
所以,一般在Python开发中,全部使用面向对象 或 面向对象和函数式混合使用
9.面对对象的应用场景
9.1 多函数需使用共同的值,如:数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码
class SqlHelper:
def __init__(self, host, user, pwd):
self.host = host
self.user = user
self.pwd = pwd
def 增(self):
# 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
# do something
# 关闭数据库连接
def 删(self):
# 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
# do something
# 关闭数据库连接
def 改(self):
# 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
# do something
# 关闭数据库连接
def 查(self):
# 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
# do something
# 关闭数据库连接# do something
9.2 需要创建多个事物,每个事物属性个数相同,但是值的需求
如:张三、李四、杨五,他们都有姓名、年龄、血型,但其都是不相同。即:属性个数相同,但值不相同
class Person:
def __init__(self, name ,age ,blood_type):
self.name = name
self.age = age
self.blood_type = blood_type
def detail(self):
temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
print temp
zhangsan = Person('张三', 18, 'A')
lisi = Person('李四', 73, 'AB')
yangwu = Person('杨五', 84, 'A')