Python 面向对象基础

Python 面向对象基础

Python从设计之初就已经是一门面向对象的语言，正因如此，在Python中创建类和对象是很容易的。首先，我们需要简单了解下面向对象的一些基本特征：
面向对象简介

• 类(Class)：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法，对象是类的实例。可以理解为"模板"；
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用；
• 数据成员：类变量或实例变量用于处理类及其实例对象的相关数据；
• 方法重写：如果从父类继承的方法不能满足子类的要求，可以对其进行改写，这个过程叫方法的覆盖(override)，也称为方法的重写；
• 实例变量：定义在方法中的变量，只作用于当前实例的类；
• 继承：即派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如：有这样一个设计，一个Dog类型的对象派生自Animal类，这是模拟"是一个(is-a)"关系(例如，Dog是一个Animal)；
• 实例化：创建一个类的实例，类的具体对象；
• 方法：类中定义的函数；
• 对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法；

和其它编程语言相比，Python在尽可能不增加新的语法和语义的情况下加入了类机制。Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法，对象可以包含任意数量和类型的数据。

类定义
语法格式：

class ClassName:
    <statement-1>
    .
    .
    .<statement-N>

类实例化后，可以使用其属性，实际上创建一个类之后，可以通过类名访问其属性。

类对象
类对象支持两种操作：属性引用和实例化；
属性引用使用和Python中所有的属性引用一样的标准语法：obj.name；
类对象创建后，类命名空间中所有的命名都是有效属性名，如下类定义：

class MyClass:
    """一个简单的类定义"""
    number = 12345

    def func(self):
        return "Hello World!"


# 实例化类
my_class = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 number 为：", my_class.number)
print("MyClass 类的方法 func 输出为：", my_class.func())

以上创建了一个新的类实例并将该对象赋值给局部变量my_class，my_class为空对象。
运行输出结果为：

MyClass 类的属性 number 为： 12345
MyClass 类的方法 func 输出为： Hello World!

很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为__init__()的特数方法(构造方法：初始化对象)，如下：

def __init__(self):
    self.data = []

定义了__init__()方法的话，类的实例化操作会自动调用__init__()方法。所以，在下例中，可以这样创建一个新的实例：

my = MyClass()

当然，init()方法可以有参数，参数通过__init__()传递到类的实例化操作上。例如：

class Complex:
    def __init__(self, realpart, imagpart):
        self.real = realpart
        self.imag = imagpart


com = Complex(3.0, -4.5)
print(com.real, com.imag)       # 3.0 -4.5

self代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别：他们必须有一个额外的第一个参数名称，按照管理它的名称是self(类的实例)；

class Test:
    def part(self):
        print(self)     # <__main__.Test object at 0x0000028F5A2B72E8>
        print(self.__class__)       # <class '__main__.Test'>


t = Test()
t.part()

从执行结果可以很明显的看出，self代表的是类的实例，代表当前对象的地址，而self.__class__则指向类。
self不是Python的关键字，我们把它换成any也是可以正常执行的：

class Test:
    def part(any):
        print(any)     # <__main__.Test object at 0x0000020AE29272E8>
        print(any.__class__)       # <class '__main__.Test'>


t = Test()
t.part()

类的方法
在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例。

# 类定义
class People:
    # 定义类属性
    name = ""
    age = 0

    # 定义私有属性，私有属性在类外部无法直接访问
    __weight = 0

    # 定义构造方法，实例化类时进行类的初始化
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说：我 %d 岁。" % (self.name, self.age))


people = People("Jack", 22, 40)
people.speak()      # Jack 说：我 22 岁。

继承
Python同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，Python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含该方法。BaseClassName(示例中的基类名)必须与派生类定义在一个作用域内，除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：

class DerivedClassName(modname.BaseClassName):

# 类定义
class People:
    # 定义类属性
    name = ""
    age = 0

    # 定义私有属性，私有属性在类外部无法直接访问
    __weight = 0

    # 定义构造方法，实例化类时进行类的初始化
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说：我 %d 岁。" % (self.name, self.age))


# 单继承示例
class Student(People):
    grade = ""

    def __init__(self, n, a, w, g):
        # 调用父类的构造函数
        People.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说：我 %d 岁了，我在读 %d 年级。" % (self.name, self.age, self.grade))


student = Student("Pony", 10, 30, 7)
student.speak()     # Pony 说：我 10 岁了，我在读 7 年级。

多继承
Python同样有限的支持多继承，多继承的类定义形式如下：

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意的是：圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python从左至右搜索即方法在子类中未找到时，从左至右查找父类中是否包含该方法(Python3多继承广度优先；Python2经典类深度优先，新式类广度优先(继承自object))：

# 类定义
class People:
    # 定义类属性
    name = ""
    age = 0

    # 定义私有属性，私有属性在类外部无法直接访问
    __weight = 0

    # 定义构造方法，实例化类时进行类的初始化
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说：我 %d 岁。" % (self.name, self.age))


# 单继承示例
class Student(People):
    grade = ""

    def __init__(self, n, a, w, g):
        # 调用父类的构造函数
        People.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说：我 %d 岁了，我在读 %d 年级。" % (self.name, self.age, self.grade))


# 另一个类，多继承之前的准备
class Speaker:
    topic = ""
    name = ""

    def __init__(self, t, n):
        self.topic = t
        self.name = n

    def speak(self):
        print("我叫 %s ，我是一个演讲家，我演讲的主题是 %s 。" % (self.name, self.topic))


# 多重继承
class Sample(Speaker, Student):
    a = ""

    def __init__(self, n, a, w, g, t):
        Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, t, n)


test = Sample("Tim", 15, 60, 9, "Python")
test.speak()        # 我叫 Tim ，我是一个演讲家，我演讲的主题是 Python 。

方法重写
如果父类的方法和功能不能满足要求，可以在子类中重写父类的方法，如下所示：

class Parent:       # 定义父类

    def my_method(self):
        print("调用父类方法。")


class Child(Parent):        # 定义子类
    def my_method(self):
        print("调用子类方法。")


child = Child()     # 子类实例
child.my_method()       # 子类调用重写方法
super(Child, child).my_method()     # 用子类对象调用父类已被覆盖的方法

运行输出结果为：

调用子类方法。
调用父类方法。

super()函数是用于调用父类(超类)的一个方法。
super()函数
super()函数是用于调用弗雷(超类)的一个方法，super()函数是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。MRO就是类的方法解析顺序表，其实也就是继承父类方法时的顺序表，其语法为：

super(type[, object-or-type])

参数：

• type：类；
• object-or-type：类实例，一般是self；

Python3和Python2的一个区别是：Python3可以直接使用super().xxx代替super(Class, self).xxx：

# Python3实例
class A:
    pass
class B(A):
    def add(self, x):
        super().add(x)

# Python2实例
class A(object):   # Python2 记得继承 object
    pass
class B(A):
    def add(self, x):
        super(B, self).add(x)

该函数无返回值，如下示例：

class FooParent:
    def __init__(self):
        self.parent = "I'm the parent."
        print("Parent.")

    def bar(self, message):
        print("%s for Parent." % message)


class FooChild(FooParent):
    def __init__(self):
        # super()首先找到FooChild的父类(FooParent)，然后把类对象FooChild转换成FooParent对象
        super().__init__()      # in Python3
        # super(FooChild, self).__init__()    # in Python2
        print("Child.")

    def bar(self, message):
        super().bar(message)        # in Python3
        # super(FooChild, self).bar(message)      # in Python2
        print("Child bar function.")
        print(self.parent)


foo_child = FooChild()
foo_child.bar("Hello World!")

运行输出结果为：

Parent.
Child.
Hello World! for Parent.
Child bar function.
I'm the parent.

类属性与方法

• 类的私有属性：__private_attrs，两个下划线开头，声明该属性为私有，不能再类的外部被使用或直接访问，在类内部的方法中使用时self.__private_attrs；
• 类的方法：在类的内部，使用def关键字来定义的一个方法，与一般函数不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例；self的名字并不是规定死的，也可以用this，但最好还是按照约定使用self；
• 类的私有方法：__private_methods，两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用，self.__private_methods；

# 类的私有属性
class JustCounter:
    __secret_counter = 0        # 私有属性
    public_counter = 0      # 公有属性

    def count(self):
        self.__secret_counter += 1
        self.public_counter += 1
        print(self.__secret_counter)


counter = JustCounter()
counter.count()
counter.count()
print(counter.public_counter)
print(counter.__secret_counter)

运行结果为：

1
2
2
Traceback (most recent call last):
  File "D:/PythonCode/oop directory/junior.py", line 116, in <module>
    print(counter.__secret_counter)        # 报错，实例不能访问私有属性
AttributeError: 'JustCounter' object has no attribute '__secret_counter'

无法访问私有属性的原因是：Python对私有属性的名字进行了改写(重写)，这样做的好处是：防止子类修改基类的属性或者方法。现在我们遍历dir(实例对象)查看类的内置方法和属性：

print(dir(counter))

运行结果为：

['_JustCounter__secret_counter', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'count', 'public_counter']

可以发现，Python将内部私有__secret_counter修改成了"_JustCounter__secret_counter"(_类名__属性名)，这就是我们无法直接访问私有属性或者方法的原因，那么既然知道了这个原因，根据修改名便可以访问它了：

print(counter._JustCounter__secret_counter)        # 2

不建议使用这种方式直接访问类的私有属性，这样做不安全也不友好。

# 类的私有方法
class Site:
    def __init__(self, name, url):
        self.name = name        # 共有属性--实例
        self.__url = url        # 私有属性--实例

    def who(self):
        print("name : ", self.name)
        print("url : ", self.__url)

    def __foo(self):        # 私有方法
        print("这是私有方法。")
    
    def foo(self):      # 公有方法
        print("这是共有方法。")
        self.__foo()


site = Site("百度", "www.baidu.com")
site.who()      # 正常输出
site.foo()      # 正常输出
site.__foo()        # 报错

运行输出结果为：

name :  百度
url :  www.baidu.com
这是共有方法。
这是私有方法。
Traceback (most recent call last):
  File "D:/PythonCode/oop directory/junior.py", line 140, in <module>
    site.__foo()        # 报错
AttributeError: 'Site' object has no attribute '__foo'

面向对象特点

• 封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏；
• 继承：可以使用现有类的所有功能，并在无需重现编写原来的类的情况下对这些功能进行扩展；
• 多态：简单理解为"一个接口，多种实现"，指一个基类派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对基类的方法做了不�