Python全栈开发-Day6-面向对象编程
本节内容:
- 面向过程VS面向对象
- 面向对象编程介绍
- 类的语法
- 构造函数、析构函数
- 私有方法、私有属性
- 面向对象的特性:封装、继承、多态
1、面向过程 VS 面向对象
编程范式
编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程,一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,实现一个任务的方式有很多种不同的方式,对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路,大多数语言只支持一种编程范式,当然也有些语言可以同时支持多种编程范式。两种最重要的编程范式分别是面向过程编程和面向对象编程。
面向过程编程(Procedural Programming)
Procedural programming uses a list of instructions to tell the computer what to do step-by-step.
面向过程编程依赖procedures,一个procedure包含一组要被进行计算的步骤,面向过程又被称为top-down languages,就是程序从上到下一步步执行,一步步从上到下,从头到尾的解决问题。基本设计思路就是程序一开始是要着手解决一个大的问题,然后把一个大问题分解成很多个小问题或子过程,这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。
举个典型的面向过程的例子,数据库备份,分三步,连接数据库,备份数据库,测试备份文件可用性。
代码如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
def db_conn(): print ( "connecting db..." ) def db_backup(dbname): print ( "导出数据库..." ,dbname) print ( "将备份文件打包,移至相应目录..." ) def db_backup_test(): print ( "将备份文件导入测试库,看导入是否成功" ) def main(): db_conn() db_backup( 'my_db' ) db_backup_test() if __name__ = = '__main__' : main() |
这样做的问题也是显而易见的,如果你要对程序进行修改,对你修改的那部分有依赖的各个部分你都也要跟着修改,举个例子,如果程序开头你设置了一个变量值为1 ,但如果其它子过程依赖这个值为1的变量才能正常运行,那如果你改了这个变量,那这个子过程你也要修改,假如又有一个其它子程序依赖这个子过程,那就会发生一连串的影响,随着程序越来越大,这种编程方式的维护难度会越来越高。
所以我们一般认为,如果你只是写一些简单的脚本,去做一些一次性任务,用面向过程的方式是极好的,但如果你要处理的任务是复杂的,且需要不断迭代和维护 的,那还是用面向对象最方便了。
面向对象编程
承认的原则:1世界万物,皆可分类。2世界万物,皆为对象。3只要是对象,就肯定属于某种品类。4只要是对象,就肯定有属性。
OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述,使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单,并且可以大大提高程序开发效率,另外,基于面向对象的程序可以使它人更加容易理解你的代码逻辑,从而使团队开发变得更从容。
面向对象的几个核心特性如下
Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、模型。在类中定义了这些对象都具备的属性(variables(data))、共同的方法。
Object 对象
一个对象即是一个类的实例化后的实例,一个类必须经过实例化后方可在程序中调用,一个类可以实例化多个对象,每个对象亦可以有不同的属性,就像人类是指所有人,每个人是指具体的对象,人与人之间有共性,亦有不同。
Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的,即类外部的程序或用户无法调用。这使类变成了一个胶囊或容器,里面包含着类的数据和方法。
Inheritance 继承
一个类可以派生出子类,在这个父类里定义的属性、方法自动被子类继承。
Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口,多种实现”,指一个基类中派生出了不同的子类,且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现,这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程,多态就是抽象化的一种体现,把一系列具体事物的共同点抽象出来,再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如,你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说:“开始工作”即可,而不需要对销售人员说:“开始销售工作”,对技术人员说:“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作,他知道这一点就行了。至于每个员工,当然会各司其职,做各自的工作。
多态允许将子类的对象当作父类的对象使用,某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定
2、面向对象编程(Object-Oriented Programming )介绍
简单的定义类并实例化的例子:
class Dog: #定义类
def bulk(self):
print('汪~汪~汪~')
d1=Dog() #实例化类,得到对象
d2=Dog()
d3=Dog()
d1.bulk() #调用d1狗下面的bulk方法或者叫属性。
d2.bulk()
d3.bulk()
- 写重复代码是非常不好的低级行为
- 你写的代码需要经常变更
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class Role( object ): def __init__( self ,name,role,weapon,life_value = 100 ,money = 15000 ): self .name = name self .role = role self .weapon = weapon self .life_value = life_value self .money = money def shot( self ): print ( "shooting..." ) def got_shot( self ): print ( "ah...,I got shot..." ) def buy_gun( self ,gun_name): print ( "just bought %s" % gun_name) r1 = Role( 'Gavin' , 'police' ,'AK47’) #生成一个角色 r2 = Role( 'Simons' , 'terrorist' ,'B22’) #生成一个角色 |
- 代码量少了近一半
- 角色和它所具有的功能可以一目了然看出来
3、类的语法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Dog( object ): def __init__( self ,name,dog_type): self .name = name self . type = dog_type def sayhi( self ): print ( "hello,I am a dog, my name is " , self .name) d = Dog( 'LiChuang' , "京巴" )#实例化这个类,此时的d就是类Dog的实例化对象 d.sayhi() #实例化,其实就是以Dog类为模版,在内存里开辟一块空间,赋值成一个变量名,存上数据 |
注释掉这两句
1
2
3
4
|
# d = Dog('LiChuang', "京巴") # d.sayhi() print (Dog) |
没实例直接打印Dog输出如下
1
|
< class '__main__.Dog' > |
这表示即使不实例化,这个Dog类本身也是已经存在内存里的
根据上图我们得知,其实self,就是实例本身!你实例化时python会自动把这个实例本身通过self参数传进去。
4、构造函数、析构函数
构造函数
1
2
3
4
5
6
7
|
class Role( object ): #定义一个类, class是定义类的语法,Role是类名,(object)是新式类的写法,必须这样写 def __init__( self ,name,role,weapon,life_value = 100 ,money = 15000 ): #初始化函数,在生成一个角色时要初始化的一些属性就填写在这里 self .name = name #__init__中的第一个参数self,和这里的self是实例本身,或者说是实例本身的内存地址 self .role = role self .weapon = weapon self .life_value = life_value self .money = money |
1
2
|
r1 = Role( 'Gavin' , 'police' ,'AK47’) #生成一个角色 , 会自动把参数传给Role下面的__init__(...)方法 r2 = Role( 'Simons' , 'terrorist' ,'B22’) #生成一个角色 |
上面的创建角色时,我们并没有给__init__传self的值,程序也没未报错,是因为,类在调用它自己的__init__(…)时自己帮你给self参数赋值了,
1
2
|
r1 = Role( 'Gavin' , 'police' , 'AK47’) #此时self 相当于 r1 , Role(r1,'Gavin ',' police ',' AK47’) r2 = Role( 'Simons' , 'terrorist' , 'B22’)#此时self 相当于 r2, Role(r2,'Simons ',' terrorist ',' B22’) |
- 在内存中开辟一块空间指向r1这个变量名
- 调用Role这个类并执行其中的__init__(…)方法,相当于Role.__init__(r1,'Gavin','police',’AK47’),这么做是为了把'Gavin','police',’AK47’这3个值跟刚开辟的r1关联起来,因为关联起来后,你就可以直接r1.name, r1.weapon 这样来调用啦。所以,为实现这种关联,在调用__init__方法时,就必须把r1这个变量也传进去,否则__init__不知道要把那3个参数跟谁关联。
- 所以这个__init__(…)方法里的,self.name = name , self.role = role 等等的意思就是要把这几个值存到r1的内存空间里。
1
2
|
def buy_gun( self ,gun_name): print (“ % s has just bought % s” % ( self .name,gun_name) ) |
1
2
|
r1 = Role( 'Gavin' , 'police' , 'AK47' ) r1.buy_gun( "B21”) #python 会自动帮你转成 Role.buy_gun(r1,”B21" ) |
- 上面的这个r1 = Role('Gavin','police','AK47’)动作,叫做类的“实例化”,就是把一个虚拟的抽象的类,通过这个动作,变成了一个具体的对象了,这个对象就叫做实例
- 刚才定义的这个类体现了面向对象的第一个基本特性,封装,其实就是使用构造方法将内容封装到某个具体对象中,然后通过对象直接或者self间接获取被封装的内容
析构函数:
作用:在实例被释放或销毁时自动执行,通常用于一些收尾工作,比如关闭临时打开的文件,断开相关链接、关闭数据库等。
例子:
class person():
def __init__(self,name,age,job):
self.name = name
self.age = age
self.job = job
def sleep(self):
pass
def eat(self):
pass
def __del__(self): #这是析构函数的定义方法
print('实例%s被释放',%self)
p = person ('Gavin',22,'IT')
5、私有方法、私有属性:
属性分两种:
1、静态属性=变量,我们一般称的属性,就是指静态属性,即变量。
2、动态属性=方法,一般方法就称为方法,不称为属性。
私有就是外部无法访问,只有自己能访问。
定义方法:
在变量名或函数名前加入两个下划线,即“__”。这时该变量或函数为私有属性或私有方法。只能内部调用,外部无法访问。如果此时就想从外部访问私有变量,则可在类的内部定义一个方法,比如def show_life_value(),然后该函数下打印该私有属性,从外部调用show_life_value方法即可。
6、面向对象的特性:
1)封装
封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。使用的方法就是私有属性和私有方法。
2)继承
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程,就是从一般到特殊的过程。
要实现继承,可以通过“继承”(Inheritance)和“组合”(Composition)来实现。
在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。
继承概念的实现方式主要有2类:实现继承、接口继承。
重构父类
经典类vs新式类
class people: #这个是 经典类
def __init__():
pass
class people(object): #新式类
def __init__():
pass
在多继承时,被继承的第二个父类不需要构造函数,即不需要把参数再传递给第二个父类,在第二个父类中,只需要添加新的功能即可。
在多继承的问题上:
- 经典类:
- Python 2.x 深度优先,People.__init__(self,name,age)
- Python 3.x 广度优先,People.__init__(self,name,age)
- 新式类:不论Python几都是广度优先,super(Man,self).__init__(name,age)
- super()用法
OOP开发范式大致为:划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
class
SchoolMember(
object
):
members
=
0
#初始学校人数为0
def
__init__(
self
,name,age):
self
.name
=
name
self
.age
=
age
def
tell(
self
):
pass
def
enroll(
self
):
'''注册'''
SchoolMember.members
+
=
1
print
(
"\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m "
%
(
self
.name,SchoolMember.members))
def
__del__(
self
):
'''析构方法'''
print
(
"\033[31;1mmember [%s] is dead!\033[0m"
%
self
.name)
class
Teacher(SchoolMember):
def
__init__(
self
,name,age,course,salary):
super
(Teacher,
self
).__init__(name,age)
self
.course
=
course
self
.salary
=
salary
self
.enroll()
def
teaching(
self
):
'''讲课方法'''
print
(
"Teacher [%s] is teaching [%s] for class [%s]"
%
(
self
.name,
self
.course,
's12'
))
def
tell(
self
):
'''自我介绍方法'''
msg
=
'''Hi, my name is [%s], works for [%s] as a [%s] teacher !'''
%
(
self
.name,'Oldboy',
self
.course)
print
(msg)
class
Student(SchoolMember):
def
__init__(
self
, name,age,grade,sid):
super
(Student,
self
).__init__(name,age)
self
.grade
=
grade
self
.sid
=
sid
self
.enroll()
def
tell(
self
):
'''自我介绍方法'''
msg
=
'''Hi, my name is [%s], I'm studying [%s] in [%s]!'''
%
(
self
.name,
self
.grade,'Oldboy')
print
(msg)
if
__name__
=
=
'__main__'
:
t1
=
Teacher(
"Gavin"
,
22
,
'Python'
,
2000
)
t2
=
Teacher(
"TengLan"
,
29
,
'Linux'
,
3000
)
s1
=
Student(
"Qinghua"
,
24
,
"Python S12"
,
1483
)
s2
=
Student(
"SanJiang"
,
26
,
"Python S12"
,
1484
)
t1.teaching()
t2.teaching()
t1.tell()
3)多态
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#_*_coding:utf-8_*_ class Animal( object ): def __init__( self , name): # Constructor of the class self .name = name def talk( self ): # Abstract method, defined by convention only raise NotImplementedError( "Subclass must implement abstract method" ) class Cat(Animal): def talk( self ): print ( '%s: 喵喵喵!' % self .name) class Dog(Animal): def talk( self ): print ( '%s: 汪!汪!汪!' % self .name) def func(obj): #一个接口,多种实现,同时这个函数可以放进父类Animal里,然后不需要实例化,直接调用父类就可以 obj.talk() c1 = Cat( '小晴' ) d1 = Dog( '李磊' ) func(c1) func(d1) |
Python全栈开发-Day6-面向对象编程的更多相关文章
- Python全栈开发【面向对象】
Python全栈开发[面向对象] 本节内容: 三大编程范式 面向对象设计与面向对象编程 类和对象 静态属性.类方法.静态方法 类组合 继承 多态 封装 三大编程范式 三大编程范式: 1.面向过程编程 ...
- Python全栈开发【面向对象进阶】
Python全栈开发[面向对象进阶] 本节内容: isinstance(obj,cls)和issubclass(sub,super) 反射 __setattr__,__delattr__,__geta ...
- Python全栈day24(面向对象编程作业作业_定义学校老师课程班级学生类)
面向对象作业 作业_定义学校老师课程班级学生类.py #面向对象编程作业,定义学校老师课程班级学生类 #定义几个类,尽可能定义多的数据属性及函数属性 class School: def __init_ ...
- Python 全栈开发七 面向对象
一.编程范式 编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 , 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所谓条条大路通罗马,实现一个任务的方式 ...
- python全栈开发-Day6 字符编码
python全栈开发-Day6 字符编码 一 .了解字符编码的知识储备 一 .计算机基础知识 二 .文本编辑器存取文件的原理(nodepad++,pycharm,word) #1.打开编辑器就打开了启 ...
- Python全栈day24-25(面向对象编程)
参考文档: http://www.cnblogs.com/linhaifeng/articles/6182264.html# 类:把一类事物的相同的特征和动作整合到一起就是类,类是抽象的概练 对象:就 ...
- python全栈开发 * 23 面向对象 知识点汇总 * 180704
23 面向对象 -----特殊方法 1. isinstance(obj,类名) 判断对象是否是此类实例化或者此类的子类实例化出来的class A:passclass B(A):passb1=B()pr ...
- python全栈开发 * 22 面向对象 知识点汇总 * 180703
22 面向对象 -----属性,类方法,静态方法,反射一.属性1.属性的定义:将方法伪装成属性,虽然在代码层面上没有任何高深之处,但让其看起来更合理. (类似于属性的方法)class Person: ...
- Python全栈开发day6
1. 简介 正则表达式本身是一种小型的.高度专业化的编程语言,而在python中,通过内嵌集成re模块,程序媛们可以直接调用来实现正则匹配.正则表达式模式被编译成一系列的字节码,然后由用C编写的匹配引 ...
- python全栈开发 * 19 面向对象 知识点汇总 * 180701
19 面向对象初识2 一.类的名称空间1.对象的名称空间对象的名称空间中有类对象指针,对象可以通过"类对象指针"找类中的"静态变量"(静态字段),也可以用对象找 ...
随机推荐
- jQuery知识总结(转)
原文:http://fwhyy.com/2013/04/jquery-knowledge-summary/ 这篇文章在于筛选器的简单例子,让人一看就懂代码的作用 20170223 前言 jQuery一 ...
- 第五章 CSS常用属性笔记
1. span标签 突显,强调局部文字的作用. 2.字体样式 font-size: 字体大小 font-style:normal,italic(倾斜) font-weight:normal,bold( ...
- webpack --watch和supervisor的不同
webpack --watch只是热打包,也就是前端代码的热加载,要实现后端代码的热加载,也就是热部署,需要使用supervisor 如何使用热部署可以参考这里:http://www.cnblogs ...
- os模块,os.path模块,subprocess模块,configparser模块,shutil模块
1.os模块 os表示操作系统该模块主要用来处理与操作系统相关的操作最常用的文件操作打开 读入 写入 删除 复制 重命名 os.getcwd() 获取当前执行文件所在的文件夹路径os.chdir(&q ...
- ODAC(V9.5.15) 学习笔记(四)TOraQuery (1)
TOraQuery是ODAC中常用的一个组件,其继承关系如下: TDataSet ---TMemDataSet ---TCustomDADataSet ---TOraDataSet ---TCusto ...
- 对应web的常用flutter应用
例如,创建一个Text widget: new Text('Hello World', style: new TextStyle(fontSize: 32.0)) 创建一个 Image widget: ...
- newcoder F石头剪刀布(DFS + 思维)题解
题意:wzms 今年举办了一场剪刀石头布大赛,bleaves 被选为负责人. 比赛共有 2n 个人参加, 分为 n 轮, 在每轮中,第 1 位选手和第 2 位选手对战,胜者作为新的第 1 位选手, 第 ...
- UVA11417 GCD
题目地址 题目链接 题解 先讨论任何没有限制的情况 \[ \large { \begin{aligned} &\sum_{i=1}^{n}\sum_{j=1}^{n}gcd(i,j)\\ &a ...
- SpringBoot JDBC 源码分析之——NamedParameterJdbcTemplate 查询数据返回bean对象
1,NamedParameterJdbcTemplate 查询列表 /***测试***/ public void queyBeanTest(){ String s = "select * f ...
- HDU 5754 Life Winner Bo(各类博弈大杂合)
http://acm.hdu.edu.cn/showproblem.php?pid=5754 题意: 给一个国际象棋的棋盘,起点为(1,1),终点为(n,m),现在每个棋子只能往右下方走,并且有4种不 ...