python学习【第九篇】python面向对象编程

一、面向对象了解

　　面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

　　Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

面向对象编程

　　OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容

面向对象的几个核心特性如下

 

Class 类

　　一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

 

Object 对象

　　一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

 

Encapsulation 封装

　　在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

 

Inheritance 继承

　　一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

 

Polymorphism 多态

　　多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。对不同类的对象发出相同的消息将会有不同的行为。

　　

二、类与对象

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

类的创建：

• 关键字：class
• 创建对象：类名称后面加()

# 创建类
class Role(object):
 
    def __init__(self):   # 构造方法，见下文讲解
        pass
 
    def show(self):       # 类中函数的第一个参数必须是self，见下文讲解
        """
 
        :return:
        """
        print("this is a role object")
 
r1 = Role()  # 创建对象
r1.show()

　类就是一个模板，模板中可以包含很多的函数

三、面向对象三大特性

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

一、封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

实现封装的步骤：

• 将内容封装到某处
• 从某处调用被封装的内容
  • 通过对象调用被封装的内容
  • 通过self间接调用被封装的内容

    def __init__(self, name, age):  # 构造函数，有name和age两个属性
        self.name = name
        self.age = age
 
    def show(self):
        """
        展示信息
        :return:
        """
        print(self.name, self.age, sep=":")  # 通过self间接调用被封装的属性值
 
    def talk(self, info):
        """
        说话
        :param info: 内容
        :return:
        """
        print(info)
 
p = People("小红", 18)  # 创建对象，将值封装到name和age属性中
print(p.age)   # 通过对象调用属性值
p.show()  # python会默认将p传给self，即self.name ==> p.name,self.age==>p.age,即self代表的是类的实例即当前对象的地址

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

对象的私有属性和私有方法

• 私有属性 就是 对象 不希望公开的 属性
• 私有方法 就是 对象 不希望公开的 方法

定义方式：

• 在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法

class Women(object):
 
    def __init__(self, name):
        self.name = name
        self.__age = 18
 
    def __secret(self):
        print("%s 的年龄是：%d" % (self.name, self.__age))
 
w1 = Women("小芳")
w1.secret()   # 私有方法不能直接方法
print(w1.age)  # 私有属性不能直接访问

　　

python中没有真正意义上的私有：

• 在给 属性、方法 命名时，实际是对 名称 做了一些特殊处理，使得外界无法访问到
• 处理方式：在 名称 前面加上 _类名 => _类名__名称

class Women(object):
 
    def __init__(self, name):
        self.name = name
        self.__age = 18
 
    def __secret(self):
        print("%s 的年龄是：%d" % (self.name, self.__age))
 
w1 = Women("小芳")
w1._Women__secret()
print(w1._Women__age)

　可以通过以上方式访问私有属性和私有访问，不推荐使用

二、继承

继承：可以实现代码的重用，相同的代码不需要重复编写

继承的概念：子类拥有父类的所有方法和属性

继承的语法：

class 类名(父类名):
    pass

　

class Animal(object):
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def eat(self):
        print("吃。。。%s, %d" % (self.name, self.age))
 
    def drink(self):
        print("喝。。。")
 
    def run(self):
        print("执行")
 
    def __play(self):
        print("玩。。。")
 
class Dog(Animal):
 
    def __init__(self, name, age):
        super().__init__(name, age)
 
    def eat(self):
        super().eat()   # Python3的使用父类方法的语法
        # Animal.eat(self)  # python2的语法，python3依然支持，但不建议使用
        print("hahaha")
 
d = Dog("小狗", 12)
d.eat()
d.play()  # 父类中私有属性和私有方法，子类不能继承

　　

多继承

多继承语法：

class 子类名(父类名1, 父类名2...)
    pass

　　

如果父类之间存在通过的方法时，建议不要使用多继承

Python 中的 MRO —— 方法搜索顺序：

　　用来查看方法的搜索顺序，主要用于多继承时判断方法、属性的调用路径：

print(Dog.__mro__)
# 执行结果
<class '__main__.Dog'>, <class '__main__.Animal'>, <class 'object'>

• 在搜索方法时，是按照 __mro__ 的输出结果 从左至右 的顺序查找的
• 如果在当前类中 找到方法，就直接执行，不再搜索
• 如果 没有找到，就查找下一个类 中是否有对应的方法，如果找到，就直接执行，不再搜索
• 如果找到最后一个类，还没有找到方法，程序报错

三、多态

多态 不同的 子类对象 调用相同的 父类方法，产生不同的执行结果

• 多态 可以 增加代码的灵活度
• 以 继承 和 重写父类方法 为前提
• 是调用方法的技巧，不会影响到类的内部设计

class Dog(object):
 
    def __init__(self, name):
        self.name = name
 
    def game(self):
        print("%s 娱乐的玩耍...." % self.name)
 
class XiaoTianDog(Dog):
 
    def __init__(self, name):
        super().__init__(name)
 
    def game(self):
        print("%s 飞到天上玩" % self.name)
 
class Person(object):
 
    def __init__(self, name):
        self.name = name
 
    def game_with_dog(self, dog):
        print("%s 和 %s 快乐的玩耍" % (self.name, dog.name))
 
        # 让狗玩耍
        dog.game()  # 传入不同的子类对象，产生的执行结果不同
 
d1 = Dog("小花")
d2 = XiaoTianDog("小白")
xiaoming = Person("小明")
xiaoming.game_with_dog(d1)
xiaoming.game_with_dog(d2)

　多态更容易写出通用的代码，做出通用的编程，以适应变化的需求

四、类属性、静态方法、类方法

在python程序中，类是一个特殊的对象---类对象，类对象有自己的属性和方法，类属性和类方法，通过类名.的方式可以访问类属性和类方法。

类方法：可以在类中通过@classmethod对方法进行修饰

静态方法：可以在类中通过@staticmethod对方法进行修饰

class Game(object):
 
    # 游戏最高分，类属性
    top_score = 0
 
    @staticmethod      # 静态方法
    def show_help():
        print("帮助信息：让僵尸走进房间")
 
    @classmethod　　　　# 类方法
    def show_top_score(cls):
        print("游戏最高分是 %d" % cls.top_score)
 
    def __init__(self, player_name):
        self.player_name = player_name
 
    def start_game(self):
        print("[%s] 开始游戏..." % self.player_name)
 
        # 使用类名.修改历史最高分
        Game.top_score = 999
 
# 1. 查看游戏帮助
Game.show_help()
 
# 2. 查看游戏最高分
Game.show_top_score()
 
# 3. 创建游戏对象，开始游戏
game = Game("小明")
 
game.start_game()
 
# 4. 游戏结束，查看游戏最高分
Game.show_top_score()

1.实例方法：方法内部可以访问实例属性

　　实例方法内部可以使用类名.访问类属性 (不推荐使用)

2.类方法：方法内部只需要访问类属性

3.静态方法：方法内部，不需要访问实例属性和类属性