Python 面向对象

面向对象编程是最有效的软件编写方法之一。
在面向对象编程中，你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。
编写类时，你定义一大类对象都有的通用行为。
基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。
根据类来创建对象被称为实例化，这让你能够使用类的实例。

创建和使用类

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

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

我们定义了一个名为Dog的类。根据约定，在Python中，首字母大写的名称指的是类。

 方法__init__()
　　类中的函数称为方法；你前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。

　　__init__()方法是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。

　　在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
我们将方法__init__()定义成了包含三个形参：self、name和age。
在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。
为何必须在方法定义中包含形参self呢？

　　因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。
每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，
让实例能够访问类中的属性和方法。

我们创建Dog实例时，Python将调用Dog类的方法__init__()。
我们将通过实参向Dog()传递名字和年龄；self会自动传递，因此我们不需要传递它。
每当我们根据Dog类创建实例时，都只需给最后两个形参（name和age）提供值。
处定义的两个变量都有前缀self。以self为前缀的变量都可供类中的所有方法使用，我们
还可以通过类的任何实例来访问这些变量。self.name = name获取存储在形参name中的值，并将
其存储到变量name中，然后该变量被关联到当前创建的实例。self.age = age的作用与此类似。

像这样可通过实例访问的变量称为属性。

根据类创建实例

*********************************************
my_dog = Dog('二哈', 2)

*********************************************

我们让Python创建一条名字为'二哈'、年龄为2的小狗。
遇到这行代码时，Python使用实参'二哈'和2 调用Dog类中的方法__init__()。
方法__init__() 创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name和age。
方法__init__()并未显式地包含return语句，但Python自动返回一个表示这条小狗的实例。
我们将这个实例存储在变量my_dog中。

在这里，命名约定很有用：
我们通常可以认为首字母大写的名称（如Dog）指的是类，
而小写的名称（如my_dog）指的是根据类创建的实例。

1. 访问属性
要访问实例的属性，可使用句点表示法。
my_dog.name
句点表示法在Python中很常用，这种语法演示了Python如何获悉属性的值。
在这里，Python先找到实例my_dog，再查找与这个实例相关联的属性name。
在Dog类中引用这个属性时，使用的是self.name。
2.调用方法
根据Dog类创建实例后，就可以使用句点表示法来调用Dog类中定义的任何方法。
my_dog.sit()
要调用方法，可指定实例的名称（这里是my_dog）和要调用的方法，并用句点分隔它们。
遇到代码my_dog.sit()时，Python在类Dog中查找方法sit()并运行其代码。

面向对象的三大特性

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

一、封装

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

将内容封装到某处
从某处调用被封装的内容

class Dog:
    def __init__(self, name, age):
        """初始化属性name和age"""
        self.name = name
        self.age = age

    # 创建类中的函数
    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + " is now sitting.")

    def get_detail(self):
        print(self.name)
        print(self.age)


# 根据类Dog创建对象my_dog
# 自动执行Dog类的 __init__ 方法
dog1 = Dog('大黄', 2)

# 1、通过对象直接调用被封装的内容
dog1.name     # 直接调用dog1对象的name属性
dog1.age        # 直接调用dog1对象的age属性

# 2、通过self间接调用被封装的内容
dog1.get_detail()
# Python默认会将dog1传给self参数，即：dog1.detail(dog1)，
#所以，此时方法内部的 self ＝ dog1，即：self.name 是 大黄 ；self.age 是 2

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

二、继承

　　编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用继承。

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。
子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self, mile):
        """
        将里程表读数设置为指定的值
        禁止将里程表读数往回调
        """
        if mile >= self.odometer_reading:
            self.odometer_reading = mile
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles


my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__()需要父类施以援手。

class ElectricCar(Car):
    """Represent aspects of a car, specific to electric vehicles."""
    def __init__(self, make, model, year):
        """
        电动汽车的独特之处
        初始化父类的属性，再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)  #调用ElectricCar的父类的方法__init__()
        self.battery_size = 70

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")


my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

#Python 2.7 中的继承
#在Python 2.7中，继承语法稍有不同，ElectricCar类的定义类似于下面这样：
class Car(object):
    def __init__(self, make, model, year):
    --snip--
class ElectricCar(Car):
    def __init__(self, make, model, year):
    super(ElectricCar, self).__init__(make, model, year)
    --snip--
#函数super()需要两个实参：子类名和对象self。
#为帮助Python将父类和子类关联起来，这些实参必不可少。
#另外，在Python 2.7中使用继承时，务必在定义父类时在括号内指定object。

#1、Python的类可以继承多个类，Java和C#中则只能继承一个类;
#2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，
#         分别是：深度优先和C3算法(广度优先)    

　　Python2.2版本之前，类都是经典类，不继承object
　　Python2.2版本之后，出现了新式类，继承object
　　Python3.x版本,默认都继承object，都是新式类

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

　　C3算法和广度优先略有不同:
　　当多继承数量较少简单时，可能相同；
　　当多继承数量较多复杂时，广度优先就会有问题.