Python基础（6） 面向对象

1 概述

　　1.1 编程方式

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

　　（2）函数式：将某功能代码封装在函数中，需要时直接调用

　　（3）面向对象：将函数进行分类和封装，让开发更好更快更强

　　Python使用类（class）和对象（object）进行面向对象编程。

　　面向对象三大特性：

　　（1）继承：解决代码的复用性问题

　　（2）封装：对数据属性严格控制，隔离复杂度

　　（3）多态性：增加程序的灵活性与可扩展性

　　1.2 类和对象

　　类是对象的类型，具有相同属性和行为事物的统称。类是抽象的，使用中会找到这个类的一个具体存在，ex：动物是类，狗是具体的。

　　万物皆对象，对象拥有自己的特征和行为。 ex：狗

　　类与对象的关系：类是对象的类型，对象是类的实例。类是抽象的概念，而对象是能够摸得着、看得见的实体。二者相辅相成，谁也离不开谁。 

2 定义类

　　类的组成部分：类型、属性、方法

　　Class 类名：

　　　　属性列表

　　　　方法列表

class Person(object):
    def __init__(self, name):     # 构造方法，实例化时自动调用
        print('我是构造方法，在实例化的时候调用！')
        self.name = name
    def SayHi(self):      # 方法就是函数
        print('大家好，我是%s!' % self.name)
p = Person("Tom")   # 实例化对象 我是构造方法，在实例化的时候调用！
p.SayHi()   # 大家好，我是Tom!

　　2.1 __init__()方法

　　__init__( )是一个特殊方法属于类的专用方法，称为类的构造函数或初始化方法，方法的前面和后面都有两个下划线。

　　每当创建类的实例化对象时，__init__( )方法默认运行，作用是初始化已实例化的对象

　　在方法定义中，第一个参数self必不可少，类方法和普通函数的区别就是self，但不是Python关键字，完全可以用其他单词取代，只是按照惯例和标准的规定，推荐使用self。

　　2.2 类属性和实例属性

　　类属性/类变量：在整个实例化的对象中是公用的，类变量定义在类方法外，通常不作为实例变量使用，函数中的使用格式为：类名.类属性。

　　实例属性/变量：定义在类方法中的变量，只作用于当前实例的类，访问方法：实例化对象名.属性

class Person(object):
    country = 'China'
    def __init__(self, name):     # 构造方法，实例化时自动调用
        self.name = name
    def SayHi(self):      # 方法就是函数
        print('大家好，我是%s来自%s！' % (self.name, Person.country))
pr1 = Person("Tom")   # 实例化对象 我是构造方法，在实例化的时候调用！
pr2 = Person('Frank')
pr1.SayHi()     # 大家好，我是Tom来自China！
pr2.SayHi()     # 大家好，我是Frank来自China！   

　　2.3 内置类属性

　　（1）__dict__：类的属性（包含一个字典，由“类的属性名.值”组成），实例化类名.__dict__

　　（2）__doc__：类的文档字符串，实例化类名.__doc__

　　（3）__name__：类名，实现方式：类名.__name__  

　　（4）__bases__：所有父类构成元素（包含一个所有父类组成的元组） 

3 继承和多态

　　编写类时，并非总是要从空白开始。可以从某个现有的class继承，新的class称为子类（Subclass），被继承的class称为基类、父类或超类。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。

class Animal():
    def __init__(self, name, food):
        self.name = name
        self.food = food
    def Eat(self):
        print('%s喜欢吃%s' % (self.name, self.food))
class Dog(Animal):
    def __init__(self, name, food, cry):
        super(Dog, self).__init__(name, food)
        self.cry = cry
    def Cry(self):
        print('%s这样叫：%s' % (self.name, self.cry))
class Cat(Animal):
    def __init__(self, name, food, cry):
        super(Cat, self).__init__(name, food)
        self.cry = cry
    def Cry(self):
        print('%s这样叫：%s' % (self.name, self.cry))
dog = Dog('小狗', '骨头', '汪汪')
dog.Eat()   # 小狗喜欢吃骨头
dog.Cry()   # 小狗这样叫：汪汪
cat = Cat('小猫', '鱼', '喵喵')
cat.Eat()   # 小猫喜欢吃鱼
cat.Cry()   # 小猫这样叫：喵喵

　　多继承：一个子类可以继承多个父类是多继承

　　当子类继承父类之后，如果子类不想使用父类的方法，可以通过重写来覆盖父类的方法。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。 

class Base(object):
    def play(self):
        print('Base is playing!')
class A(Base):  # 继承Base
    def play(self):  # 自动覆盖父类的此方法
        print('A is playing')
class B(Base):  # 继承Base
    def play(self):
        print('B is playing')
class C(A, B):  # 继承A,B
    # pass      # 采用覆盖后的方法：A is playing
    def play(self):     # 调用父类中的方法：Base is playing!
        Base.play(self)
c = C()
c.play()   

4 访问限制

　　要让内部属性或者方法不被外部访问，可以把在属性或者方法的名称前加上单下划线_， 或者在前面加双下划线__，或者两边加双下划线。

　　（1）保护类型：一个下划线开头“_foo”，只允许类本身和子类可以访问；　

　　（2）私有类型：双下划线开头“__foo”，外部不可通过“对象.属性名”来访问或者更改，实际将其转化成了“_类名__属性名”；　　

　　（3）两边加双下划线“__foo__”：系统方法或函数。

class Swan:
    """天鹅类"""
    _neck_swan = "天鹅的脖子很长"  # 保护类型的属性
    def __init__(self):
        print("__init__(): ", Swan._neck_swan)  # 访问保护类型的属性
swan = Swan()  # 实例化Swan类的实例（对象）
print("直接访问：", swan._neck_swan)  # 通过实例名访问保护类型的属性
# __init__():  天鹅的脖子很长
# 直接访问： 天鹅的脖子很长 

5 类方法与静态方法

　　5.1 实例方法

　　定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；

　　调用：只能由实例对象调用。

　　5.2 类方法

　　定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；

　　调用：实例对象和类对象都可以调用。

应用场景

假设我有一个学生类和一个班级类，想要实现的功能为：
    执行班级人数增加的操作、获得班级的总人数；
    学生类继承自班级类，每实例化一个学生，班级人数都能增加；
    最后，我想定义一些学生，获得班级中的总人数。 

　　5.3 静态方法

　　定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

　　调用：实例对象和类对象都可以调用。

　　静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。

　　譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。

import time
class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second
    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())
print(TimeTest.showTime())      # 13:19:34
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)      # 13:19:34