9类与对象

9.1 面向对象

类和对象是面向对象中的重要概念。面向对象是一种编程思想，即按照现实世界的思维方式构建软件系统。

9.2定义类

Python中的数据类型都是类，我们可以自定义类，即创建一种新的数据类型。语法格式如下：

class Car(object):# 类体pass

Car类继承了object 类，object类是所有类的根类，在Python中人任何一个类都直接或间接地继承了object'，直接继承object时部分代码可以省略。

注：pass语句只用于维持程序结构的完整。我们在编程时若不想马上编写某些代码，又不想语法错误，就可以用pass语句占位。

9.3创建对象

类有点像生物中的概念，在一个类中的对象我们也可以把它叫做实例。

# coding = utf-8class Car(object):# 类体passcar = Car（）

与C++不同的是，Python不需要程序员手动释放对象。

9.4 类的成员

         成员变量也被称为数据成员，保存了类或对象的数据。例如，学生的姓名和学号。

        构造方法是一种特殊的函数，用于初始化类的成员变量。

        成员方法是在类中定义的函数。

        属性是对类进行封装而提供的特殊方法。

        实例变量和实例方法属于对象，通过对象调用，而类变量和类方法属于类，通过类调用。

 9.4.1实例变量

        实例变量就是对象个体特有的“数据”，例如狗狗的名称和年龄等。

# coding = utf-8class Dog:def __init__(self, name, age):self.name = name # 创建和初始化实例变量nameself.age = age # 创建和初始化实例变量d = Dog('球球', 2)
print('我们家狗狗名叫{0}，{1}岁了。'.format(d.name, d.age))

        类中的self表示当前对象，构造方法中的self参数说明这个方法属于实例，self.age中的self表示age属于实例，即实例成员变量。

9.4.2 构造方法

        类中的__init__（）方法是一个非常特殊的方法，用来创建和初始化实例变量，这种方法就是”构造方法“。在定义__init__（）方法时，它的第一个参数应该是self，之后的参数用来初始化实例变量。调用构造方法时不需要传入self参数。

        构造方法的示例代码如下：

# coding = utf-8class Dog:def __init__(self, name, age, sex='雌性'):self.name = nameself.age = ageself.sex = sexd1 = Dog('球球', 2)
d2 = Dog('哈哈',1，'雌性')
d3 = Dog(name = '拖布'， sex='雌性'，age=3)print('{0}:{1}岁{2}。'.format(d1.name, d1.age, d1.sex))
print('{0}:{1}岁{2}。'.format(d2.name, d2.age, d2.sex))
print('{0}:{1}岁{2}。'.format(d1.name, d3.age, d3.sex))

9.4.3 实例方法

        实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。

        定义实例方法时，它的第一个参数也应该是self，这会将当前实例与该方法绑定起来，这也说明该方法属于实例。在调用方法时不需要传入self，类似于构造方法。

        下面看一个定义实例方法的示例：

# coding = utf-8class Dog:# 构造方法def __init__(self, name, age, sex='雌性'):self.name = nameself.age = ageself.sex = sex# 实例方法def run(self):print("{}在跑...".format(self.name))# 实例方法def speak(self, sound):print('{}在叫，"{}"!'.format(self.name, sound))dog = Dog('球球', 2)
dog.run()
dog.speak('汪 汪 汪')

9.4.4 类变量

        类变量是属于类的变量，不属于单个对象。

        例如，有一个Account（银行账户）类，它有三个成员变量：amount（账户金额）、interest_rate（利率）和owner（账户名）。amount和owner对于每一个账户都是不同的，而interest_rate对于所有账户都是相同的。amount和owner是实例变量，interest——rate是所有账户实例共享的变量，它属于类，被称为“类变量”。

        类变量的示例代码如下：

# coding = utf-8class Account:interest_rate = 0.0568def __init__(self, owner, amount):self.owner = ownerself.amount = amountaccount = Account('Tony', 800000.0)
print('账户名：{0}'.format(account。owner))
print('账户金额：{0}'.format(account.amount))
print('利率：{0}'.format(Account.interest_rate))

9.4.5 类方法

        类方法与类变量类似，属于类，不属于个体实例。在定义类方法时，它的第一个参数不是self，而是类本身。

        定义类方法的示例代码如下：

# coding = utf-8class Account:interest_rate = 0.0668def __init__(self, owner, amount):self.owner = ownerself.amount = amount# 类方法@classmethoddef interest_by(cls, amt): #  cls表示自身return cls.interest_rate * amt # cls可以用Account代替interest = Account.interest_by(12000.0)
print('计算利息：{0:.4f}'.format(interest))

9.5 封装性

        封装性是面向对象重要的基本特性之一。封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。

9.5.1 私有变量

        为了防止外部调用者随意存取类的内部数据（成员变量），内部数据（成员变量）会被封装为“私有变量”。外部调用者只能通过方法调用私有变量。

        在默认情况下，Python中的变量是公有的，可以在类的外部访问它们。如果想让它们成为私有变量，则在变量前加上双下划线即可。

# coding = utf-8class Account:__interest_rate = 0.0568def __init__(self, owner, amount):self.owner = ownerself.__amount = amountdef desc(self):print("{0} 金额：{1} 利率：{2}。".format(self.owner, self.__amount, Account.__interest_rate))account = Account('Tony', 800000.0)
account.desc()print('账户名：{0}'.format(account。owner))
print('账户金额：{0}'.format(account.__amount)) # 错误发生
print('利率：{0}'.format(Account.__interest_rate)) # 错误发生

9.5.2 私有方法

        私有方法与私有变量的封装是类似的，在方法前加上双下划线就是私有方法了。示例代码如下:

# coding = utf-8class Account:__interest_rate = 0.0568def __init__(self, owner, amount):self.owner = ownerself.__amount = amountdef __get_info(self):return "{0} 金额：{1} 利率：{2}。"。format(self.owner,self.__amount,Account.__interest_rate)def desc(self):print(self.__get_info())account = Account('Tony', 800000.0)
account.desc()
account.__get_info() # 发生错误

9.5.3 使用属性

        为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set（赋值）和get（取值）方法访问。

        使用set和get方法进行封装，示例代码如下：

# coding = utf-8class Dog:# 构造方法def __init__(self, name, age, sex='雌性'):self.name = nameself.__age = ageself.sex = sex# 实例方法def run(self):print("{}在跑...".format(self.name))# get 方法def get_age(self):return self.__age# set方法def set_age(self, age)self.__age = agedog = Dog('球球', 2)
print('狗狗年龄： {}'.format(dog.get_age))
dog.set_age(3)
print('修改后狗狗的年龄：{}'.format(dog.get_age())

        使用属性方式修改上面的示例，代码如下：

# coding = utf-8class Dog:# 构造方法def __init__(self, name, age, sex='雌性'):self.name = nameself.__age = ageself.sex = sex# 实例方法def run(self):print("{}在跑...".format(self.name))@propertydef age(self):  # 代替get_age(self)return self.__age@age.setterdef age(self, age):  # 替代set_age(self,age)self.__age = agedog = Dog('球球', 2)
print('狗狗年龄： {}'.format(dog.age))
dog.age = 3   # dog.set_age(3)
print('修改后狗狗的年龄：{}'.format(dog.age)

9.6 继承性

        继承性也是面向对象重要的基本特性之一。

9.6.1 Python中的继承

        在Python中声明子类继承父类，定义类时在类的后面使用一对小括号指定它的父类就可以了。

# -*- coding: utf-8 -*-class Animal:def __init__(self, name):self.name = name # 实例变量namedef show_info(self):return "动物的名字：{0}".format(self.name)def move(self):print("动一动。。。")class Cat(Animal):def __init__(self, name, age):super().__init__(name)  # 调用父类构造方法，初始化父类成员变量self.age = age  # 实例变量 agecat = Cat('Tom', 2)
cat.move()
print(cat.show_info())

        子类继承父类的时候会把父类的公有成员变量和方法继承。

9.6.2 多继承

         Python支持多继承，如果在多个父类中有相同的成员方法或成员变量，则子类优先继承左边父类中的成员方法或成员变量，从左到右继承级别从高到低。

        示例代码如下：

# -*- coding: utf-8 -*-class Horse:def __init__(self, name):self.name = name # 实例变量namedef show_info(self):return "马的名字：{0}".format(self.name)def run(self):print("马跑。。。")class Donkey:def __init__(self, name):self.name = name # 实例变量namedef show_info(self):return "驴的名字：{0}".format(self.name)def run(self):print("驴跑。。。")def roll(self):print("驴打滚。。。")class Mule(Horse, Donkey):def __init__(self, name, age):super().__init__(name)self.age = age # 实例变量agem = Mule('骡子',1)
m.run() # 继承父类Horse方法
m.roll() # 继承父类Donkey方法
print(m.show_info()) # 继承父类Horse方法

9.6.3 方法重写

        如果子类的方法名与父类的方法名相同，则在这种情况下，子类的方法会重写父类的同名方法。示例代码如下：

# -*- coding: utf-8 -*-class Horse:def __init__(self, name):self.name = name # 实例变量namedef show_info(self):return "马的名字：{0}".format(self.name)def run(self):print("马跑。。。")class Donkey:def __init__(self, name):self.name = name # 实例变量namedef show_info(self):return "驴的名字：{0}".format(self.name)def run(self):print("驴跑。。。")def roll(self):print("驴打滚。。。")class Mule(Horse, Donkey):def __init__(self, name, age):super().__init__(name)self.age = age # 实例变量agedef show_info(self):return "骡：{0}，{1}岁。".format(self.name, self.age)m = Mule('骡子',1)
m.run() # 继承父类Horse方法
m.roll() # 继承父类Donkey方法
print(m.show_info()) # 继承父类Horse方法

9.7 多态性

        多态性也是面向对象重要的基本特征之一。“多态”指对象可以表现出多种形态。

9.7.1 继承与多态

        在多个子类继承父类，并且重写父类方法之后，这些子类所创建的对象之间就是多态的。并且这些对象采用不同的方式实现父类方法。示例代码如下：

# -*- coding: utf-8 -*-class Animal:def speak(self):print('动物叫，但不知道是什么玩意在叫')class Dog(Animal):def speak(self):print("汪汪汪")class Cat(Animal):def speak(self):print("喵喵喵")an1 = Dog()
an2 = Cat()
an1.speak()
an2.speak()

        还有一种方式：

# -*- coding: utf-8 -*-class Animal:def speak(self):print('动物叫，但不知道是什么玩意在叫')class Dog(Animal):def speak(self):print("汪汪汪")class Cat(Animal):def speak(self):print("喵喵喵")class Car:def speak(self):print("小火车：呜呜呜")def start(obj):obj.speak()start(Dog())
start(Cat())