python——面向对象编程

面向对象编程

面向对象编程是一种编程方式,此编程方式需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。

  • 类(class)就是一个模板,模板里可以包含多个函数,函数里实现一些功能
  • 对象则是根据模板创建的实例,通过实例对象可以执行类中的函数
 1 # 创建类
 2 class Foo(object):    #新式类(经典类 class Foo:)
 3 
 4     def Bar(self):
 5 
 6         print 'Bar'
 7 
 8     def Hello(self, name):
 9 
10         print 'i am %s' %name
11 
12 # 根据类Foo创建对象obj
13 
14 obj = Foo()
15 
16 obj.Bar()            #执行Bar方法
17 
18 obj.Hello('x54256') #执行Hello方法

面向对象3大特点:

一、封装 

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

所以,在使用面向对象的封装特性时,需要:

  • 将内容封装到某处
  • 从某处调用被封装的内容(在类中的其他函数中需要通过self来间接的调用被封装的内容)

 1 class Foo(object):
 2     def __init__(self,name,age):    #构造函数,根据类创建对象时(实例化)自动执行
 3         self.name=name
 4         self.age=age
 5     
 6     def run():
 7         print("%s今年%s岁了。"%(self.name,self.age)
 8         
 9 
10 #实例化(就是将内容封装到某处)
11 #实际上alex和22被封装到了obj1中,x54256和21被封装到了obj2中
12 
13 obj1=Foo('alex',22)
14 
15 obj2=Foo('x54256',21)
16 
17 
18 #若要调用必须从obj1,obj2中调用封装的内容
19 
20 print(obj1.name)
21 print(obj2.name)
22 
23 #要从被封装的地方调用类中的函数
24 
25 obj1.run()    
26 obj2.run()
封装代码

二、继承

继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容。

例如:

  猫可以:喵喵叫、吃、喝、拉、撒

  狗可以:汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,如下所示:

 1 class 猫:
 2 
 3     def 喵喵叫(self):
 4         print '喵喵叫'
 5 
 6     def 吃(self):
 7         # do something
 8 
 9     def 喝(self):
10         # do something
11 
12     def 拉(self):
13         # do something
14 
15     def 撒(self):
16         # do something
17 
18 class 狗:
19 
20     def 汪汪叫(self):
21         print '喵喵叫'
22 
23     def 吃(self):
24         # do something
25 
26     def 喝(self):
27         # do something
28 
29     def 拉(self):
30         # do something
31 
32     def 撒(self):
33         # do something
34 
35 伪代码
伪代码

上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:

  动物:吃、喝、拉、撒

     猫:喵喵叫(猫继承动物的功能)

     狗:汪汪叫(狗继承动物的功能)

 1 class 动物:
 2 
 3     def 吃(self):
 4         # do something
 5 
 6     def 喝(self):
 7         # do something
 8 
 9     def 拉(self):
10         # do something
11 
12     def 撒(self):
13         # do something
14 
15 # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
16 class 猫(动物):
17 
18     def 喵喵叫(self):
19         print '喵喵叫'
20         
21 # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
22 class 狗(动物):
23 
24     def 汪汪叫(self):
25         print '喵喵叫'
26 
27 伪代码
伪代码
 1 class Animal:
 2 
 3     def eat(self):
 4         print "%s 吃 " %self.name
 5 
 6     def drink(self):
 7         print "%s 喝 " %self.name
 8 
 9     def shit(self):
10         print "%s 拉 " %self.name
11 
12     def pee(self):
13         print "%s 撒 " %self.name
14 
15 
16 class Cat(Animal):
17 
18     def __init__(self, name):
19         self.name = name
20         self.breed = ''
21 
22     def cry(self):
23         print '喵喵叫'
24 
25 class Dog(Animal):
26     
27     def __init__(self, name):
28         self.name = name
29         self.breed = ''
30         
31     def cry(self):
32         print '汪汪叫'
33         
34 
35 # ######### 执行 #########
36 
37 c1 = Cat('小白家的小黑猫')
38 c1.eat()
39 
40 c2 = Cat('小黑的小白猫')
41 c2.drink()
42 
43 d1 = Dog('胖子家的小瘦狗')
44 d1.eat()

三、多态

多态性(polymorphisn)是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。
那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!多态的作用,就是为了类在继承和派生的时候,保证使用“家谱”中任一类的实例的某一属性时的正确调用。
 1 class Animal(object):
 2 
 3     def __init__(self, name):  # Constructor of the class
 4 
 5         self.name = name
 6 
 7     def talk(self):              # Abstract method, defined by convention only
 8 
 9         raise NotImplementedError("Subclass must implement abstract method")
10 
11 class Cat(Animal):
12 
13     def talk(self):
14 
15         print('%s: 喵喵喵!' %self.name)
16 
17 
18 class Dog(Animal):
19 
20     def talk(self):
21 
22         print('%s: 汪!汪!汪!' %self.name)
23 
24 
25 def func(obj): #一个接口,多种形态
26 
27     obj.talk()
28 
29 
30 c1 = Cat('小晴')
31 
32 d1 = Dog('李磊')
33 
34 
35 func(c1)
36 
37 func(d1)

领域模型 

领域模型就是对需求所涉及的领域的一个建模,更通俗的讲法是业务模型。 参考百度百科领域模型定义如下: (http://baike.baidu.cn/view/757895.htm )

从这个定义我们可以看出,领域模型有两个主要的作用:

  1. 发掘重要的业务领域概念
  2. 建立业务领域概念之间的关系 

领域域建模的方法就是“从用例中找名词”。 当然,找到名词后,为了能够更加符合面向对象的要求和特点,我们还需要对这些名词进一步完善,这就 是接下来的步骤:加属性,连关系

1.找名词

who : 学员、讲师、管理员

用例:

1. 管理员 创建了 北京 和 上海 两个校区

2. 管理员 创建了 Linux \ Python \ Go 3个课程 

3. 管理员 创建了 北京校区的Python 16期, Go开发第一期,和上海校区的Linux 36期 班级

4. 管理员 创建了 北京校区的 学员 小晴 ,并将其 分配 在了 班级  python 16期 

5. 管理员 创建了 讲师 Alex , 并将其分配 给了 班级 python 16期 和全栈脱产5期

6. 讲师 Alex 创建 了一条 python 16期的 上课纪录 Day6 

7. 讲师 Alex 为Day6这节课 所有的学员 批了作业 ,小晴得了A, 李磊得了C-, 严帅得了B

8. 学员小晴 在 python 16 的 day6里 提交了作业 

9. 学员李磊 查看了自己所报的所有课程 

10 学员 李磊  在 查看了 自己在 py16期 的 成绩列表 ,然后自杀了

11. 学员小晴  跟 讲师 Alex 表白了

名词列表:

管理员、校区、课程、班级、上课纪录、作业、成绩、讲师、学员

2.加属性

3.连关系 

有了类,也有了属性,接下来自然就是找出它们的关系了。

 

总结

以上就是本节对于面向对象初级知识的介绍,总结如下:

  • 面向对象是一种编程方式,此编程方式的实现是基于对  和 对象 的使用
  • 类 是一个模板,模板中包装了多个“函数”供(对象)使用
  • 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数
  • 面向对象三大特性:封装、继承和多态

问答专区

问题一:什么样的代码才是面向对象?

答:从简单来说,如果程序中的所有功能都是用 类 和 对象 来实现,那么就是面向对象编程了。

问题二:函数式编程 和 面向对象 如何选择?分别在什么情况下使用?

答:须知:对于 C# 和 Java 程序员来说不存在这个问题,因为该两门语言只支持面向对象编程(不支持函数式编程)。而对于 Python 和 PHP 等语言却同时支持两种编程方式,且函数式编程能完成的操作,面向对象都可以实现;而面向对象的能完成的操作,函数式编程不行(函数式编程无法实现面向对象的封装功能)。

所以,一般在Python开发中,全部使用面向对象面向对象和函数式混合使用

面向对象的应用场景:

 

1.多函数需使用共同的值,如:数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码

 1 class SqlHelper:
 2 
 3     def __init__(self, host, user, pwd):
 4 
 5         self.host = host
 6         self.user = user
 7         self.pwd = pwd
 8 
 9     def 增(self):
10         # 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
11         # do something
12         # 关闭数据库连接
13 
14     def 删(self):
15         # 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
16         # do something
17         # 关闭数据库连接
18 
19     def 改(self):
20         # 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
21         # do something
22         # 关闭数据库连接
23 
24     def 查(self):
25     # 使用主机名、用户名、密码(self.host 、self.user 、self.pwd)打开数据库连接
26         # do something
27         # 关闭数据库连接# do something
伪代码

2.需要创建多个事物,每个事物属性个数相同,但是值的需求
如:张三、李四、杨五,他们都有姓名、年龄、血型,但其都是不相同。即:属性个数相同,但值不相同

 

 1 class Person:
 2 
 3     def __init__(self, name ,age ,blood_type):
 4 
 5         self.name = name
 6         self.age = age
 7         self.blood_type = blood_type
 8 
 9 
10     def detail(self):
11         temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
12         print temp
13 
14 zhangsan = Person('张三', 18, 'A')
15 lisi = Person('李四', 73, 'AB')
16 yangwu = Person('杨五', 84, 'A')
实例代码

问题三:类和对象在内存中是如何保存?

答:类以及类中的方法在内存中只有一份,而根据类创建的每一个对象都在内存中需要存一份,大致如下图:

 

 

posted @ 2017-10-18 19:06  想54256  阅读(458)  评论(0编辑  收藏  举报