Python学习总结：Python之面向对象（初级篇）

概述

• 面向过程：根据业务逻辑从上到下写垒代码
• 函数式：将各个功能封装到函数中，相关功能无需重复编写，调用即可
• 面向对象：对函数进行分类和封装，让开发更好更快的进行开发工作

# 面向过程编程代码

while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
 
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
 
    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

函数式编程，增强代码的重用性和可读性，同样的功能代码实现如下

def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接
 
while True：
 
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
 
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
 
    if 内存占用 > 80%:
        发送邮件('内存报警')

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

注：Java和C#来说只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程

 

创建类和对象

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

• 类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
• 对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

 

• class是关键字，表示类
• 创建对象，类名称后面加括号即可

注：类中的函数第一个参数必须是self，类中定义的函数叫做方法

# 创建一个简单的类
class Foo:                           　　# 定义一个类
    def bar(self):                  　　# 类的第一个方法
        print('bar')

    def hello(self, name):   　　 # 类的第二个方法
        print("I am %s" % name)

obj = Foo()                    　　    # 根据Foo创建对象obj
obj.bar()                        　　    # 执行bar方法
obj.hello("xiao ming")    　　   # 执行hello方法

对比实现同一个功能，函数编程及面向对象实现的方法

• 面向对象：【定义类】【创建对象】【通过对象执行类的方法】
• 函数编程：【定义函数】【调用函数】

总结：函数式的应用场景-->各个函数之间是独立且无公共数据的

面向对象特性

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

1、封装

概念：封装就是讲内容封装到某个地方，以后再去调用被封装在某处的内容

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

• 将内容封装到某处(可以被封装的内容有哪些)
• 从某处调用被封装的内容(如果在多层封装中找到指定的方法并调用)

 第一步：将内容封装到某处

self是一个形式参数，当执行obj1 =Foo（‘wupeiqi’，18）时，self等于obj1,当执行obj1 =Foo（‘alex’，28）时，self等于obj2

所以，内容其实被封装到了对象obj1和obj2中，每个对象中都有name和age属性，在内存中进行类似的数据存储

第二步：从某处调用被封装的内容

调用被封装的内容，有两种情况：

• 通过对象直接调用
• 通过self间接调用

# 方法1：通过对象直接调用
class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
obj1 = Foo('wupeiqi', 18)
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性
 
obj2 = Foo('alex', 73)
print obj2.name    # 直接调用obj2对象的name属性
print obj2.age     # 直接调用obj2对象的age属性


# 方法2：通过self间接调用被封装的内容（执行类中的方法时，需要通过self间接调用被封装的内容）
class Foo:
  
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    def detail(self):
        print self.name
        print self.age
  
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
  
obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

综上所述：对于面向对象的封装来讲，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容

练习题1：在终端输出如下信息

    小明，10岁，男，上山去砍柴
    小明，10岁，男，开车去东北
    小明，10岁，男，最爱大保健

    老李，90岁，男，上山去砍柴
    老李，90岁，男，开车去东北
    老李，90岁，男，最爱大保健

    老张...

def kan_chai(name, age, sex):
    print("%s,%s岁,%s,上山去砍柴" % (name, age, sex))


def qu_dong_bei(name, age, sex):
    print("%s,%s岁,%s,开车去东北" % (name, age, sex))


def da_bao_jian(name, age, sex):
    print("%s,%s岁,%s,最爱大保健" % (name, age, sex))


if __name__ == '__main__':
    kan_chai('小明', 10, '男')
    qu_dong_bei('小明', 10, '男')
    da_bao_jian('小明', 10, '男')
    kan_chai('老李', 90, '男')
    qu_dong_bei('老李', 90, '男')
    da_bao_jian('老李', 90, '男')
    kan_chai('老张', 90, '男')
    qu_dong_bei('老张', 90, '男')
    da_bao_jian('老张', 90, '男')

class Foo:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def kan_chai(self):
        print("%s,%s岁,%s,上山去砍柴" % (self.name, self.age, self.sex))

    def da_bao_jian(self):
        print("%s,%s岁,%s,开车去东北" % (self.name, self.age, self.sex))

    def kan_chai(self):
        print("%s,%s岁,%s,最爱大保健" % (self.name, self.age, self.sex))

obj1 = Foo("小明", 10, "男")
obj1.kan_chai()
obj1.da_bao_jian()
obj1.kan_chai()

obj2 = Foo('老李', 90, '男')
obj2.kan_chai()
obj2.da_bao_jian()
obj2.kan_chai()

obj3 = Foo('老张', 90, '男')
obj3.kan_chai()
obj3.da_bao_jian()
obj3.kan_chai()

对比结果：函数式编程需要在每次执行时传入相同的参数，如果参数较多，需要大量的复制粘贴；而面向对象编程只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。

练习题2：游戏人生程序
1、创建三个游戏人物，分别是：

    苍井井，女，18，初始战斗力1000
    东尼木木，男，20，初始战斗力1800
    波多多，女，19，初始战斗力2500

2、游戏场景，分别：

    草丛战斗，消耗200战斗力
    自我修炼，增长100战斗力
    多人游戏，消耗500战斗力

class GameLife:
    def __init__(self, name, sex, age, level):
        self.name = name
        self.sex = sex
        self.age = age
        self.level = level
        self.cc = 0
        self.yx = 0
        self.xl = 0

    def cao_cong(self):
        self.level = self.level - 200
        self.cc += 1

    def xiu_lian(self):
        self.level = self.level + 100
        self.xl += 1

    def you_xi(self):
        self.level = self.level - 500
        self.yx += 1

    def detail(self):
        print("姓名：%s,性别：%s,年龄：%s,当前%s战斗力"
              "\n多人游戏:%s"
              "\n自我修炼:%s"
              "\n草丛战斗:%s" % (self.name, self.sex, self.age, self.level, self.yx, self.xl, self.cc))


# ##################创建角色######################
cjj = GameLife('苍井井', '女', 18, 1000)
dnmm = GameLife('东尼木木', '男', 20, 1800)
bdd = GameLife('博多多', '女', 19, 2500)


# ##################进行战斗######################
cjj.cao_cong()
cjj.cao_cong()
cjj.you_xi()
dnmm.you_xi()
bdd.cao_cong()
bdd.xiu_lian()

# #################查看各个角色信息################
cjj.detail()
dnmm.detail()
bdd.detail()

 2、继承

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

例如：

　　猫：喵喵叫、吃、喝、拉、撒

　　狗：汪汪叫、吃、喝、拉、撒

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

class 猫：

    def 喵喵叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

通过上述代码，可以将猫和狗都具有的功能提取出来，统一实现，然后猫和狗使用继承的思想，不用每一类动物都实现那些公共的功能

例如：

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫自己的功能+继承动物的功能）

　　　狗：汪汪叫（狗自己的功能+继承动物的功能）

class Animal:
    def eat(self):
        print("%s 吃" % self.name)

    def drink(self):
        print("%s 喝" % self.name)

    def shit(self):
        print("%s 拉" % self.name)

    def pee(self):
        print("%s 撒" % self.name)


class Cat(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print("%s 喵喵叫" % self.name)
        

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '狗'

    def cry(self):
        print("%s 汪汪叫" % self.name)

# ##############执行#################
obj1 = Cat('汤姆')
obj1.eat()


obj2 = Dog('大黄')
obj2.cry()
obj2.drink()

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

注：除了子类和父类的称谓，还可以叫派生类和基类，但是两者不要混淆即可

多继承问题

• 是否可以继承多个类
• 如果继承多个类每个类中都定义了相同的函数，那么继承顺序如何？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

• 当类是经典类时，多继承情况下，会按照深度优先方式查找
• 当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

 

class D:

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

经典类多继承

class D(object):

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

注：Python3都是新式类，Python2和Python3差异：Python 2区分新式类和经典类，两种类的多继承查找方法方法不同

class A(object):
    def f1(self):
        print('A')

class B(A):
    def f1(self):
        print('B')
class C(A):
    def f1(self):
        print('C')

class D(B):
    def f1(self):
        print('D')

class E(C):
    def f1(self):
        print('E')

class F(D,E):
    def f1(self):
        print('f')

obj = F()
obj.f1()

3、多态

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

面向对象编程总结

面向对象知识总结：

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

常见问题解答:

问题一：什么样的代码才是面向对象？

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

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

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

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

面向对象的应用场景:

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

Demo

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')

问题三：类和对象在内存中是如何保存？

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

如上图所示，根据类创建对象时，对象中除了封装 name 和 age 的值之外，还会保存一个类对象指针，该值指向当前对象的类。

当通过 obj1 执行 【方法一】 时，过程如下：

1. 根据当前对象中的 类对象指针 找到类中的方法
2. 将对象 obj1 当作参数传给 方法的第一个参数 self