Python之类

第九章 类

9.1 创建和使用类

什么事面向对象编程，面向对象编程就是你编写一些表示现实世界中的事物和场景的类，并基于这些类来创建对象。

根据类来创建对象被称为实例化，这让你能够使用类的实例。

9.1.1 创建dog类

下列创建了一个dog类来解释如和创建类：

❶ 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 roll_over(self): _

               """模拟小狗被命令时打滚"""

                print(self.name.title() + " rolled over!")

分析：

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

1. 方法_init_()

类中的函数称为方法，

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

在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。

每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

❹处定义的两个变量都有前缀self 。

以self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。

self.name = name 获取存储在形参name 中的值，并将其存储到变量name 中，然后该变量被关联到当前创建的实例。self.age = age 的作用与此类似。像这样可通过实例访问的变量称为属性。

注意：self后面的为变量。

9.1.2 根据类创建实例

下面是一个根据Dog类来创建的实例：

class Dog():

        --snip--

❶ my_dog = Dog('willie', 6)

❷ print("My dog's name is " + my_dog.name.title() + ".")

❸ print("My dog is " + str(my_dog.age) + " years old.")

1. 访问属性

要访问实例的属性，可使用句点表示法。

例如：

my_dog.name

1. 调用方法

要调用方法，可指定实例的名称和要调用的方法，并用句点分隔它们

例如：

my_dog.sit()

1. 创建多个实例

可按需求根据类创建任意数量的实例

例如：

my_dog = Dog('willie', 6)

your_dog = Dog('lucy', 3)

9.2 使用类和实例

9.2.1 Car类

下面编写了一个表示汽车的类：

class Car():

        """一次模拟汽车的简单尝试“”“

        def _init_(self,make,model,year):

                """初始化描述汽车的属性“”“

                self.make = make

                self.model =model

                self.year = year

        def get_descriptive_name(self):

                """返回整洁的描述信息“”“

                long_name = str(self.year) + " “ + self.make + " " self.model

                return long_name.title()

my_new_car = Car('audi','a4',2016)

print(my_new_car.get_descriptive_name())

9.2.2 给属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。

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):

                --snip--

        ❷ def read_odometer(self):

                """打印一条指出汽车里程的消息"""

                print("This car has " + str(self.odometer_reading) + " miles on it.")

my_new_car = Car('audi', 'a4', 2016)

print(my_new_car.get_descriptive_name()) my_new_car.read_odometer()

在此例中，我们通过方法_init_()来创建实例，以属性的方式存储了制造商，模型，使用年份。我们还定义了一个获取汽车里程数的方法。

9.2.3 修改属性的值

在Python中，可以使用三种方法修改属性的值

1. 直接修改属性的值

要修改属性的值，可直接通过实例调用属性来修改属性的值。

例如：

class Car():

        --snip--

my_new_car = Car('audi', 'a4', 2016)

print(my_new_car.get_descriptive_name())

❶ my_new_car.odometer_reading = 23

my_new_car.read_odometer()

在❶ 中，我们通过实例调用属性的方法来修改属性的值

1. 通过方法修改属性的值

如果在类中定义了修改属性的方法，你可以直接调用方法来修改属性的值。

例如：

class Car():

        --snip--

        ❶ def update_odometer(self, mileage):

                """将里程表读数设置为指定的值"""

                self.odometer_reading = mileage

my_new_car = Car('audi', 'a4', 2016)

print(my_new_car.get_descriptive_name())

❷ my_new_car.update_odometer(23)

my_new_car.read_odometer()

1. 通过方法对属性的值进行递增

有时候需要将属性值递增特定的量，而不是将其设置为全新的值。

例如：

class Car():

        --snip--

        def update_odometer(self, mileage):

                --snip--

        ❶ def increment_odometer(self, miles):

                """将里程表读数增加指定的量"""

                self.odometer_reading += miles

❷ my_used_car = Car('subaru','outback',2013)

print(my_used_car.get_descriptive_name())

❸ my_used_car.update_odometer(23500) my_used_car.read_odometer()

❹ my_used_car.increment_odometer(100) my_used_car.read_odometer()

在上述Car类中，❶定义了一个对于后续里程表改变的方法。在❷❸❹中，初始了一个叫做my_used_car的实例，并通过实例调用类中的方法，并修改了里程数。

注意：你可以使用类似于上面的方法来控制用户修改属性值（如里程表读数）的方式，但能够访问程序的人都可以通过直接访问属性来将里程表修改为任何值。要确 保安全，除了进行类似于前面的基本检查外，还需特别注意细节。

9.3 继承

编写类时，并非总要从空白开始。如果你要编写的类是另一个现成类的版本，可使用继承。一个类继承另一个类时，他将自动获得另一个类的所有属性和方法，原有的类称为父类 ，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

9.3.1 子类的方法_init_()

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

例如：

❶ 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, mileage):

                if mileage >= self.odometer_reading:

                        self.odometer_reading = mileage

                else:

                        print("You can't roll back an odometer!")

        def increment_odometer(self, miles):

                self.odometer_reading += miles

❷ class ElectricCar(Car):

        """电动汽车的独特之处"""

        ❸ def init(self, make, model, year):

                """初始化父类的属性"""

                ❹ super().init(make, model, year)

❺ my_tesla = ElectricCar('tesla', 'model s', 2016)

print(my_tesla.get_descriptive_name())

在❶处，创建子类时，父类必须包含在当前文件中，且为与子类前面。

在❷处，定义子类时，必须在括号内指定父类的名称

在❸处，方法__init__() 接受创建Car 实例所需的信息

在❹处，super() 是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar 的父类的方法__init__() ，让ElectricCar 实例包含父类的所有属性。父类也成为超类。

9.3.2 python2.7中的继承

在Python2.7中，继承语法稍有不同。

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 2.7中使用继承时，务必在定义父类时在括号内指 定object 。

9.3.3 给子类定义属性和方法

让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。

例如：

class Car():

        --snip--

class ElectricCar(Car):

        """Represent aspects of a car, specific to electric vehicles."""

        def init(self, make, model, year):

                """ 电动汽车的独特之处初始化父类的属性，再初始化电动汽车 特有的属性 """

                super().init(make, model, year)

                ❶ 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()

在此例中，我们定义了一个ElectricCar类来继承父类Car,并给子类定义了一个名为battery的属性和一个名为describe_battery()的方法。

9.3.4 重写父类方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

例如：

def ElectricCar(Car):

        --snip--

def fill_gas_tank():

        """电动汽车没有油箱"""

        print("This car doesn't need a gas tank!")

9.3.5 将实例用作属性

在某些情况下，你需要交一个大类的某些方法拿出来，从而构造新的类，将其实例用作属性。

例如：

class Car():

        --snip--

        ❶ class Battery():

                """一次模拟电动汽车电瓶的简单尝试"""

                ❷ def init(self, battery_size=70):

                        """初始化电瓶的属性"""

                        self.battery_size = battery_size

                ❸ def describe_battery(self):

                        """打印一条描述电瓶容量的消息"""

                        print("This car has a " + str(self.battery_size) + "-kWh battery.")

class ElectricCar(Car):

        """电动汽车的独特之处"""

        def init(self, make, model, year):

        """ 初始化父类的属性，再初始化电动汽车特有的属性 """

                super().init(make, model, year)

                ❹ self.battery = Battery()

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

在此例中，我们定义了一个叫Battery的类，在定义ElectricCar类时，我们将Battery类的实例赋给了battery，这个ElectricCar类中的属性。然后通过对ElectricCar类实例化，通过ElectricCar类实例调用battery属性在通过battery属性调用Battery的方法。

9.4 导入类

9.4.1 导入单个类

要导入单个类，方法如下：

❶ from car import Car

my_new_car = Car('audi', 'a4', 2016)

print(my_new_car.get_descriptive_name()) my_new_car.odometer_reading = 23

my_new_car.read_odometer()

❶处的import 语句让Python打开模块car ，并导入其中的Car 类。

注意：模块是扩展名为.py的文件。

9.4.2 在一个模块中存储多个类

在一个模块中，可以存储多个类。

例如：

"""一组用于表示燃油汽车和电动汽车的类"""

class Car():

        --snip--

class Battery():

        --snip--

class ElectricCar(Car):

        --snip--

9.4.3 从一个模块中导入多个类

在Python中，可以从一个模块中导入多个类。

例如：

❶ from car import Car, ElectricCar

在❶处从一个模块中导入多个类时，用逗号分隔了各个类。导入必要的类后，就可根据需要创建每个类的任意数量的实例。

9.4.4 导入整个模块

在Python中，还可以导入整个模块，再使用句点表示法访问需要的类。

例如：

❶ import car

❷ my_beetle = car.Car('volkswagen', 'beetle', 2016)

print(my_beetle.get_descriptive_name())

❸ my_tesla = car.ElectricCar('tesla', 'roadster', 2016)

print(my_tesla.get_descriptive_name())

要访问模块中的类，使用语法 module_name.class_name 访问需要的类

9.4.5 导入模块中的所有类

要导入模块中的每个类，可使用下面的语法：

from module_name import *

注意：需要从一个模块中导入很多类时，最好导入整个模块，并使用 module_name.class_name 语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知 道在程序的哪些地方使用了导入的模块；你还避免了导入模块中的每个类可能引发的名称冲突。

9.4.6 在一个模块中导入另一个模块

有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。 在这种情况下，可在前一个模块中导入必要的类。

例如：

下面将Car 类存储在一个模块中，并将ElectricCar 和Battery 类存储在另一个模块中。我们将第二个模块命名为electric_car.py ，并将Battery 和ElectricCar 类复制到这个模块中：

electric_car.py

❶ from car import Car

class Battery():

        --snip--

class ElectricCar(Car):

        --snip--

此在❶处，我们直接将Car 类导入该模块中。如果我们忘记了这行代码，Python将在我们试图创建ElectricCar 实例时引发错误。

car.py

class Car():

        --snip--

9.5 类编程风格

1. 类名应采用驼峰命名法 ，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
2. 对于每个类，都应紧跟在类定义后面包含一个文档字符串。每个模块也都应包含一个文 档字符串，对其中的类可用于做什么进行描述。
3. 在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
4. 需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句

9.6 小结

在本章中，你学习了：如何编写类；如何使用属性在类中存储信息，以及如何编写方法，以让类具备所需的行为；如何编写方法__init__() ，以便根据类创建包含所需属性的实例。你见识了如何修改实例的属性——包括直接修改以及通过方法进行修改。你还了解了：使用继承可简化相关类的创建工作；将一个类的实例用作另一个类的属性可让类更简洁。