python运维开发哪家好_python运维开发(七)----面向对象（上）

内容目录：

面向对象应用场景

类和对象的创建

类中的__init__构造方法

self理解

面向对象的三大特性：封装、继承、多态

概述

面向过程：根据业务逻辑从上到下写垒代码

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

面向对象应用场景

当某一些函数具有相同参数时，可以使用面向对象的方式，将参数值一次性的封装到对象，以后去对象中取值即可

类和对象的创建

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

类是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

class是关键字，表示类

创建对象，类名称后加括号即可

类中的函数第一个参数必须是self

类中定义的函数叫做 “方法“

# 创建类

class SQLHELPER:

def fetch(self,sql):

print(obj.hhost)

print(obj.username)

print(obj.passwd)

print(sql)

def create(self,sql):

pass

def remove(self,sql):

pass

def modify(self,sql):

pass

# 根据类SQLHELPER创建对象obj

obj = SQLHELPER()

obj.hhost = 'c1.salt.com' #相同的参数封装在对象中

obj.username = 'root'

obj.passwd = '123'

obj.fetch('select * from A;')#执行fetch方法

类中的__init__构造方法

在类中有__init__的构造方法自动执行，我们通常可以将公共的参数写入到init方法中

class Foo:

def __init__(self):

print('自动被执行')

self.hhost = 'c1.salt.com' #将hhost变量写入到init方法中

self.username = 'root' #将username 变量写入到init方法中

self.pwd= '123' #将pwd变量写入到init方法中

obj = Foo()

#输出：

自动被执行

应用

class Foo:

def __init__(self,a1,a2,a3): #通过传参来写init方法

print('自动被执行')

self.hhost = a1

self.username = a2

self.root = a3

print(a1,a2,a3)

def fetch(self):

pass

def remove(self):

pass

def modify(self):

pass

def create(self):

pass

obj1 = Foo('c1.salt.com','root1','123')

obj2 = Foo('c2.salt.com','root2','123')

self的理解

self是python自动会给传值的参数

哪个对象执行方法，self就是谁

obj1.fetch('select * ....') self = obj1

obj2.fetch('select * ....') self = obj2

面向对象的三大特性

面向对象的三大特性是指：封装、继承和多态。

1、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要如下的操作：

将内容封装到某处

从某处调用被封装的内容

可以从下面的图中事例来理解封装

self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都封装了 name 和 age ，之前说的“内容封装到某处”其在内容里类似于下图来保存。

练习：

1、创建三个游戏人物，分别是：

苍井井，女，18，初始战斗力1000

东尼木木，男，20，初始战斗力1800

波多多，女，19，初始战斗力2500

2、游戏场景，分别：

草丛战斗，消耗200战斗力

自我修炼，增长100战斗力

多人游戏，消耗500战斗力

# -*- coding:utf-8 -*-

# ##################### 定义实现功能的类 #####################

class Person:

def __init__(self, na, gen, age, fig):

self.name = na

self.gender = gen

self.age = age

self.fight =fig

def grassland(self):

"""注释：草丛战斗，消耗200战斗力"""

self.fight = self.fight - 200

def practice(self):

"""注释：自我修炼，增长100战斗力"""

self.fight = self.fight + 200

def incest(self):

"""注释：多人游戏，消耗500战斗力"""

self.fight = self.fight - 500

def detail(self):

"""注释：当前对象的详细情况"""

temp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s" % (self.name, self.gender, self.age, self.fight)

print temp

# ##################### 开始游戏 #####################

cang = Person('苍井井', '女', 18, 1000) # 创建苍井井角色

dong = Person('东尼木木', '男', 20, 1800) # 创建东尼木木角色

bo = Person('波多多', '女', 19, 2500) # 创建波多多角色

cang.incest() #苍井空参加一次多人游戏

dong.practice()#东尼木木自我修炼了一次

bo.grassland() #波多多参加一次草丛战斗

#输出当前所有人的详细情况

cang.detail()

dong.detail()

bo.detail()

cang.incest() #苍井空又参加一次多人游戏

dong.incest() #东尼木木也参加了一个多人游戏

bo.practice() #波多多自我修炼了一次

#输出当前所有人的详细情况

cang.detail()

dong.detail()

bo.detail()

2、继承

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

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

普通继承:子类继承父类的方法和字段

多重继承:当前类可以继承多个子类，子类中又可以继承子类

然而就出现了这样的先后顺序问题：

图中，C3类继承C1和C2,C1类继承C0，现在对C3进行实例化obj = C3()，执行obj.f2()

先后顺序

1 判断自己C3中是否有f2的方法，如果没有从左边第一个子类C1中进行查找；

2 判断C中存在则直接调用C1中的f2方法，如果C1中没有f2方法则在进行深度查找，找到C1的子类C0中查找；

3 判断如果在C0中存在则返回，如果C0中也不存在则会重复2步，进行深度查找子类，直到所有子类都遍历完成；

4 判断如果3步中都没有f2的方法，则去遍历C3中右边的继承C2中查找是否有f2的方法，有则返回无则抛出异常。

对于此图与上面图对比可知，C0和C1 有调用公共的子类，遍历顺序则深度遍历到公共子类C_2的下一级C0时不会再下一级遍历寻找了,

会寻找C3继承的第二个子类C2中进行遍历，即进行横向遍历，如果C2中也不存在则进行深度遍历到C_1中遍历，直到找到C_2中为止。

参考url：http://www.cnblogs.com/wupeiqi/p/4493506.html