快捷搜索:
来自 计算机编程 2019-08-11 06:04 的文章
当前位置: 67677新澳门手机版 > 计算机编程 > 正文

67677新澳门手机版:类与对象

一、类简介

类和对象

1.下面编写一个表示小狗的类Dog作为例子:

 1 class Dog():
 2     '''一次模拟小狗的简单尝试'''
 3 
 4     def __init__(self, name, age):
 5         '''初始化属性name和age'''
 6         self.name = name
 7         self.age = age
 8 
 9     def sit(self):
10         '''模拟小狗蹲下'''
11         print(self.name.title() ' is now sitting.')
12 
13     def roll(self):
14         '''模拟小狗打滚'''
15         print(self.name.title() ' rolled over!')

 根据约定,Python中首字母大写的名称指的是类

类中的函数称为方法,方法与函数的唯一差别是调用方法的方式。

        上述例子中,__init__() 是一个特殊的方法,构造方法,开头和末尾各有两个下划线,指的是Python的默认方法。其中的形参特殊,self 必不可少且位于其他参数前面,在Python调用 __init__() 方法创建Dog实例时,将自动传入实参self,每个与类相关联的方法调用都自动传递实参self,它是指向实例本身的引用,让实例能够访问类中的属性和方法。以 self 为前缀的变量可供类中所有方法使用。像这样可以通过实例访问的变量称为属性

在Python2.7中,需要做细微的修改,声明改为:class Dog(object):

  类是用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。基于类创建 对象时,每个对象都自动具备这种通用行为,然后可根据需要赋予每个对象独特的个性。根据类来创建对象被称为 实例化,这让我们能够使用类的实例。

2.根据类创建实例

1 my_dog = Dog('willie', 6)
2 print('My dog`s name is ' my_dog.name.title() '. ')
3 print('My dog is ' str(my_dog.age) ' years old. ')
4 my_dog.sit()
5 my_dog.roll()

 方法 __init__() 自动返回一个小狗的实例,存储在 my_dog 中,在这里,命名约定为 首字母大写的名称表示类,小写的名称指的是根据类创建的实例。

要访问实例的属性或方法,可使用句点描述法。

1. 类与对象的创建和使用

二、使用类和实例

  使用类几乎可以模拟任何东西。在Python 3 中,创建和使用类的具体格式如下:

1.Car类

 1 class Car():
 2     '''一次模拟汽车的简单尝试'''
 3 
 4     def __init__(self, make, model, year):
 5         '''初始化描述汽车的属性'''
 6         self.make = make
 7         self.model = model
 8         self.year = year
 9         self.odometer_reading = 0
10 
11     def get_descriptive_name(self):
12         '''返回整洁的描述性信息'''
13         long_name = str(self.year) ' ' self.make ' ' self.model
14         return long_name.title()
15 
16     def read_odometer(self):
17         '''打印一条指出汽车里程的消息'''
18         print('This car has ' str(self.odometer_reading) ' miles on it. ')
19 
20 
21 my_car = Car('audi', 'a4', '2016')
22 print(my_car.get_descriptive_name())
23 my_car.read_odometer()

以上创建一个汽车的类,存储汽车的信息

其中,odometer_reading 属性初始值为0,相当于指定了默认值

如果想要修改属性的值,大概有三种方法:直接通过实例进行修改,通过方法进行设置,通过方法进行递增。下面依次介绍:

  class ClassName():

2.直接修改属性的值

最简单的方式是通过实例直接访问它

 1 my_car.odometer_reading = 23 

    """ 文档字符串 1"""

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

在类中添加方法去更改属性的值,可以同时进行扩展,添加一些逻辑比如禁止往回调:

1     def update_odometer(self, mileage):
2         '''
3         将里程表读数设置为指定的值
4         禁止将里程表读数往回调
5         '''
6         if mileage > self.odometer_reading:
7             self.odometer_reading = mileage
8         else:
9             print("You can`t roll back an odometer! ")

    def __init__(self,[属性1],[属性2],,..[属性N])

三、继承

一个类继承另一个类时,它将自动获得另一个类的所有属性和方法,原有的类称为 父类或超类,新类称为 子类

      self.属性1 = 属性1

 1.子类的方法 __init__() 

创建子类的实例时,Python首先需要完成的任务是给父类的所有属性赋值,下面举个简单例子;

 1 class ElectricCar(Car):
 2     '''电动汽车的独特之处'''
 3 
 4     def __init__(self, make, model, year):
 5         '''初始化父类的属性'''
 6         super().__init__(make, model, year)
 7 
 8 
 9 my_tesla = ElectricCar('tesla', 'model s', 2016)
10 print(my_tesla.get_descriptive_name())

创建子类的时候。父类必须包含在当前文件中,且位于子类前面,括号内指定父类的名称。

super() 是一个特殊函数,可以将子类和父类关联起来,上面第6行调用父类的方法

Python2.7中的继承语法稍有不同,super(ElectricCar,self).__init__(make,model,year)

      self.属性2 = 属性2

2.给子类定义属性和方法、

扩充上面的代码

 1 class ElectricCar(Car):
 2     '''电动汽车的独特之处'''
 3 
 4     def __init__(self, make, model, year):
 5         '''
 6         初始化父类的属性
 7         再初始化电动汽车特有的特性
 8         '''
 9         super().__init__(make, model, year)
10         self.battery_size = 70
11 
12     def describe_battery(self):
13         '''打印一条描述电瓶容量的消息'''
14         print('This car has a ' str(self.battery_size) '-KWh battery. ')
15 my_tesla.describe_battery()

第10行添加新属性并初始化

          .

3.重写父类的方法

在子类中定义一个和父类方法同名的方法,Python将忽略父类中该方法

1     def get_descriptive_name(self):
2         '''重写父类的该方法'''
3         long_name = str(self.year) ' ' self.make ' ' self.model ' with ' str(self.battery_size) '-KWh battery'
4         return long_name.title()

          .

4.综合运用

 1 class Car():
 2     '''一次模拟汽车的简单尝试'''
 3 
 4     def __init__(self, make, model, year):
 5         '''初始化描述汽车的属性'''
 6         self.make = make
 7         self.model = model
 8         self.year = year
 9 
10     def get_descriptive_name(self):
11         '''返回整洁的描述性信息'''
12         long_name = str(self.year) ' ' self.make ' ' self.model
13         return long_name.title()
14 
15 
16 class Battery():
17     '''一次模拟电瓶的简单尝试'''
18 
19     def __init__(self, battert_size=70):
20         '''初始化电瓶的属性'''
21         self.battert_size = battert_size
22 
23     def describe_battery(self):
24         '''打印一条描述电瓶容量的消息'''
25         print('This car has a ' str(self.battert_size) '-KWh battery. ')
26 
27 
28 class ElectricCar(Car):
29     '''电动汽车的独特之处'''
30 
31     def __init__(self, make, model, year):
32         '''
33         初始化父类的属性
34         再初始化电动汽车特有的特性
35         '''
36         super().__init__(make, model, year)
37         self.battery = Battery()
38 
39 
40 my_tesla = ElectricCar('tesla', 'model s', 2016)
41 print(my_tesla.get_descriptive_name())
42 my_tesla.battery.describe_battery()

          .

四、导入类

Python允许将类存储在模块中,然后在主程序中导入所需的模块

      self.属性N= 属性N

1.导入单个类

#car.py
'''一个可用于表示汽车的类'''


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



#my_car.py
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()

      self.属性x= 默认值1

2.在一个模块中存储多个类

可根据需要在一个模块中存储任意数量的类

 1 # car.py
 2 '''一组用于表示燃油汽车和电动汽车的类'''
 3 
 4 
 5 class Car():
 6     '''一次模拟汽车的简单尝试'''
 7 
 8     def __init__(self, make, model, year):
 9         '''初始化描述汽车的属性'''
10         self.make = make
11         self.model = model
12         self.year = year
13         self.odometer_reading = 0
14 
15     def get_descriptive_name(self):
16         '''返回整洁的描述性信息'''
17         long_name = str(self.year) ' ' self.make ' ' self.model
18         return long_name.title()
19 
20     def read_odometer(self):
21         '''打印一条指出汽车里程的消息'''
22         print('This car has ' str(self.odometer_reading) ' miles on it. ')
23 
24     def update_odometer(self, mileage):
25         '''
26         将里程表读数设置为指定的值
27         禁止将里程表读数往回调
28         '''
29         if mileage >= self.odometer_reading:
30             self.odometer_reading = mileage
31         else:
32             print("You can`t roll back an odometer! ")
33 
34     def increment_odometer(self, miles):
35         '''将里程表读数增加指定的量'''
36         self.odometer_reading  = miles
37 
38 
39 class Battery():
40     '''一次模拟电瓶的简单尝试'''
41 
42     def __init__(self, battert_size=70):
43         '''初始化电瓶的属性'''
44         self.battert_size = battert_size
45 
46     def describe_battery(self):
47         '''打印一条描述电瓶容量的消息'''
48         print('This car has a ' str(self.battert_size) '-KWh battery. ')
49 
50     def get_range(self):
51         '''打印一条描述电瓶续航里程的消息'''
52         if self.battert_size == 70:
53             range = 240
54         elif self.battert_size == 85:
55             range = 270
56         message = 'This car can go approximately ' str(range)
57         message  = ' miles on a full charge. '
58         print(message)
59 
60 
61 class ElectricCar(Car):
62     '''电动汽车的独特之处'''
63 
64     def __init__(self, make, model, year):
65         '''
66         初始化父类的属性
67         再初始化电动汽车特有的特性
68         '''
69         super().__init__(make, model, year)
70         self.battery = Battery()
71 
72 
73 
74 # my_electric_car.py
75 from car import ElectricCar
76 
77 my_tesla = ElectricCar('tesla', 'model s', 2016)
78 print(my_tesla.get_descriptive_name())
79 my_tesla.battery.describe_battery()
80 my_tesla.battery.get_range()

      self.属性y= 默认值1

3. 从一个模块中导入多个类

1 from car import Car, ElectricCar
2 
3 my_beetle = Car('volkswagen', 'beetle', 2016)
4 print(my_beetle.get_descriptive_name())
5 
6 my_tesla = ElectricCar('tesla', 'roadster', 2016)
7 print(my_tesla.get_descriptive_name())

 

4.导入整个模块

导入整个模块之后使用句点描述法访问需要的类

1 import car
2 
3 my_beetle = car.Car('volkswagen', 'beetle', 2016)
4 print(my_beetle.get_descriptive_name())
5 
6 my_tesla = car.ElectricCar('tesla', 'roadster', 2016)
7 print(my_tesla.get_descriptive_name())

    def function_name(self,[属性x],[属性y]]):

5.导入模块中的所有类

不推荐这种方式,万一同名会发生错误

1 from car import *
2 
3 my_beetle = Car('volkswagen', 'beetle', 2016)
4 print(my_beetle.get_descriptive_name())
5 
6 my_tesla = ElectricCar('tesla', 'roadster', 2016)
7 print(my_tesla.get_descriptive_name())

 

如果需要引入一个模块中的很多类时,最好导入整个模块,然后用句点描述法访问类(上述"导入整个模块"的方法),这样做可以清楚地知道程序的哪些地方使用了导入的模块,还避免了名称冲突。

      """ 文档字符串2 """ 

6.在一个模块中导入另一个模块

就是嵌套着一层层import,不详述

      self.属性x=属性x

五、Python标准库

Python标准库是一组模块,安装的Python都包含它。下面以模块 collections 中的 OrderedDict 类为例说明:

OrderedDict类是记录顺序的字典

 1 from collections import OrderedDict
 2 
 3 favorite_languages = OrderedDict()  # 创建一个空的有序字典
 4 
 5 favorite_languages['jen'] = 'python'
 6 favorite_languages['sarah'] = 'c'
 7 favorite_languages['edward'] = 'ruby'
 8 favorite_languages['phil'] = 'python'
 9 
10 for name, language in favorite_languages.items():
11     print(name.title() "'s favorite language is " language.title() '.')

      self.属性y= 属性y

六、类编码风格

类名:应采用驼峰命名法,每个单词首字母大写,且不使用下划线

实例名、模块名:采用小写格式,单词之间使用下划线

 

对于每个类和模块,都应该紧跟着 文档字符串

 

在类中,使用一个空行分隔方法

在模块中,使用两个空行分隔类

 

导入模块时,先导入标准库模块,再添加一个空行,然后导入自己写的模块

  return 返回值   

 

变量 = ClassName([属性1],[属性2],,..[属性N])  

变量.function_name

  说明:

  (1)创建类使用关键字class。

  (2)类名的首字母必须大写,且类名有多个单词组成时,每个单词的首字母都需大写,中间不需要使用任何符号,紧接着写即可。

  (3)类中的函数称为方法。每个类都具有内置的方法__init__(),该方法的名称中,开头和末尾各有两个下划线,这是一种约定,旨在避免Python默认方法与普通方法发生名称冲突。其中除self之外,还能具有其他属性,还能给属性指定默认值。

  (4)在类中。可定于除__init__()之外的其他函数,其可用于属于自己的属性。

  (5)可以将属性的新值覆盖默认值。

  (6)类的使用直接使用类名,紧接括号,然后再在括号中提供相应的值。

  (7)为了方便,一般将调用类返回的结果赋值给一遍变量,然后再用变量.function_name,即可调用类中的方法。

       

  例如,创建汽车的类,并调用它。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8     def get_descriptive_name(self):
 9         """返回整洁的描述性信息"""
10         long_name = str(self.year)   ' '   self.make   ' '   self.model
11         return long_name.title()
12 
13 my_car = Car('audi', 'Q8', 2018)
14 print(my_car.get_descriptive_name())

  说明:

  第1行,用关键字class创建一个汽车的类Car。

  第2行,使用文档字符串概述该类的所能完成的任务。

  第3~7行,使用关键字 def 定义了__init__() 方法,并对其属性进行初始化。

  第8~11行,用关键字def创建get_descriptive_name()方法,返回整洁的描述信息。

  第13行,调用创建的Car类,实例化一个对象,给对象将会鞠咏该类的属性和方法。

  第14行,调用类中的get_descriptive_name()方法。

 

  运行结果:

2018 Audi Q8

 

  注:

  在Python2.7 中创建类的唯一区别是,需要在类名的括号中写上object,即:

    class ClassName (object):

 

67677新澳门手机版 ,2.  指定属性的默认值

  类中的每个属性都必须有初始值,哪怕这个值是0或空字符串。在有些情况下,如设置默认值时,在方法 __init__() 内指定这种初始值是可行的;如果你对某个属性这样做了,就无需包含为它提供初始值的形参。

  例如,我们给类Car添加一个名为 odometer_reading 的属性,其初始值总是为0。我们再添加了一个名为read_odometer() 的方法,用于读取汽车的里程表。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8         self.odometer_reading = 0
 9 
10     def get_descriptive_name(self):
11         """返回整洁的描述性信息"""
12         long_name = str(self.year)   ' '   self.make   ' '   self.model
13         return long_name.title()
14 
15     def read_odometer(self):
16         """打印一条指出汽车里程的消息"""
17         print("This car has "   str(self.odometer_reading)   " miles on it.")
18 
19 my_car = Car('audi', 'Q8', 2018)
20 print(my_car.get_descriptive_name())
21 print(my_car.read_odometer())

  说明:

  第8行,增加了一个属性 odometer_reading ,并将其初始化为0。

  第15~17行,用def关键字定义了一个read_odometer() 方法,用于读取汽车的里程表。

  第21行,调用新增加的read_odometer() 方法。

  

  运行结果:

1 2018 Audi Q8
2 This car has 0 miles on it.
3 None

  从以上运行结果可知,当我们没有给方法指定返回值时,则其默认返回None。

 

3. 修改属性的值

3.1 直接修改属性的值

  要修改属性的值,最简单的方式是通过实例直接访问它。

  例如,在类Car中,直接将里程表读数设置20。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8         self.odometer_reading = 0
 9 
10     def get_descriptive_name(self):
11         """返回整洁的描述性信息"""
12         long_name = str(self.year)   ' '   self.make   ' '   self.model
13         return long_name.title()
14 
15     def read_odometer(self):
16         """打印一条指出汽车里程的消息"""
17         print("This car has "   str(self.odometer_reading)   " miles on it.")
18 
19 my_car = Car('audi', 'Q8', 2018)
20 print(my_car.get_descriptive_name())
21 my_car.read_odometer()
22 
23 my_car.odometer_reading = 20
24 my_car.read_odometer()

  说明:

  第23行,直接将汽车的属性odometer_reading的值改为20。

  第24行,再次调用read_odometer()方法,显示汽车里程表的数据。

 

  运行结果:

1 2018 Audi Q8
2 This car has 0 miles on it.
3 This car has 20 miles on it.

  从以上运行结果可知,里程表读数被修改为20。

 

3.2 通过方法修改属性的值

  在类中增加修改方法属性的值,这样每次只修将值传给该方法即可。

  例如,在类Car中,增加一个修改属性odometer_reading值的方法update_odometer()。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8         self.odometer_reading = 0
 9 
10     def get_descriptive_name(self):
11         """返回整洁的描述性信息"""
12         long_name = str(self.year)   ' '   self.make   ' '   self.model
13         return long_name.title()
14 
15     def read_odometer(self):
16         """打印一条指出汽车里程的消息"""
17         print("This car has "   str(self.odometer_reading)   " miles on it.")
18 
19     def update_odometer(self, mileage):
20         """将里程表读数设置为指定的值"""
21 
22         self.odometer_reading = mileage
23 
24 my_car = Car('audi', 'Q8', 2018)
25 print(my_car.get_descriptive_name())
26 my_car.read_odometer()
27 
28 my_car.update_odometer(20)
29 my_car.read_odometer()

  说明:

  第19~22行,用关键字def定义了一个update_odometer()方法,用于接受汽车里程来修改里程表的数据。

  第28行,调用类中的update_odometer()方法,并传给其一个20的值。该方法会用该值取修改属性的初始化的值0。

 

  运行结果:

1 2018 Audi Q8
2 This car has 0 miles on it.
3 This car has 20 miles on it.

 

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

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

  例如,在类Car中,增加一个方法increment_odometer() ,接受一个值,修改属性odometer_reading的为递增的形式。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8         self.odometer_reading = 0
 9 
10     def get_descriptive_name(self):
11         """返回整洁的描述性信息"""
12         long_name = str(self.year)   ' '   self.make   ' '   self.model
13         return long_name.title()
14 
15     def read_odometer(self):
16         """打印一条指出汽车里程的消息"""
17         print("This car has "   str(self.odometer_reading)   " miles on it.")
18 
19     def update_odometer(self, mileage):
20         """将里程表读数设置为指定的值"""
21         self.odometer_reading = mileage
22 
23     def increment_odometer(self, miles):
24         """将里程表读数增加指定的量"""
25         self.odometer_reading  = miles
26 
27 my_car = Car('audi', 'Q8', 2018)
28 print(my_car.get_descriptive_name())
29 my_car.read_odometer()
30 
31 my_car.update_odometer(20)
32 my_car.read_odometer()
33 
34 my_car.increment_odometer(10)
35 my_car.read_odometer()

  说明:

  第23~25行,使用关键字def定义了一个increment_odometer()方法,将汽车的里程数据递增。

 

  运行结果:

1 2018 Audi Q8
2 This car has 0 miles on it.
3 This car has 20 miles on it.
4 This car has 30 miles on it.

  从以上的运行结果可知,汽车的里程表数据默认为0,然后被修改为20,最后在原有的基础上递增了10,所以最终为30。

 

2.  继承

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

 

2.1 子类的 __init__()方法

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

  例如,电动汽车是一种特殊的汽车,创建新类 ElectricCar 来继承 Car类 。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8         self.odometer_reading = 0
 9 
10     def get_descriptive_name(self):
11         """返回整洁的描述性信息"""
12         long_name = str(self.year)   ' '   self.make   ' '   self.model
13         return long_name.title()
14 
15     def read_odometer(self):
16         """打印一条指出汽车里程的消息"""
17         print("This car has "   str(self.odometer_reading)   " miles on it.")
18 
19     def update_odometer(self, mileage):
20         """将里程表读数设置为指定的值"""
21         self.odometer_reading = mileage
22 
23     def increment_odometer(self, miles):
24         """将里程表读数增加指定的量"""
25         self.odometer_reading  = miles
26 
27 class ElectricCar(Car):
28     """电动汽车的独特之处"""
29     def __init__(self, make, model, year):
30         """初始化父类的属性"""
31         super().__init__(make, model, year)
32 
33 my_tesla = ElectricCar('tesla', 'model s', 2018)
34 print(my_tesla.get_descriptive_name())

  说明:

  第27行,使用关键字class 定义了一个电动汽车的类ElectricCar,并且继承了汽车的类Car。

  第29行,使用关键字def 定义__init__()方法,该方法接受创建 Car 实例所需的信息。

  第31行, 使用super() 方法将父类和子类关联起来。

  注意:以上所有定义类和调用类方法时,都是在Python3中进行的,如果实在Python 2.7中,继承语法稍有不同, 需要在super() 方法的括号中写上父类名称及self。那么31行需改为以下形式:

  super(ElectricCar, self).__init__(make, model, year)  

 

  运行结果:

2018 Tesla Model S

 

2.2 给子类定义属性和方法

  子类经过继承,毕竟可拥有父类的属性和方法,还能定义自己特有的属性和方法。

  例如,电动汽车不仅具有汽车的属性和方法,还有一个电瓶的属性。现在给其增加一个属性battery_size,并创建一个方法来显示它的容量。

  代码:

 1 class Car():
 2     """一次模拟汽车的简单尝试"""
 3     def __init__(self, make, model, year):
 4         """初始化描述汽车的属性"""
 5         self.make = make
 6         self.model = model
 7         self.year = year
 8         self.odometer_reading = 0
 9 
10     def get_descriptive_name(self):
11         """返回整洁的描述性信息"""
12         long_name = str(self.year)   ' '   self.make   ' '   self.model
13         return long_name.title()
14 
15     def read_odometer(self):
16         """打印一条指出汽车里程的消息"""
17         print("This car has "   str(self.odometer_reading)   " miles on it.")
18 
19     def update_odometer(self, mileage):
20         """将里程表读数设置为指定的值"""
21         self.odometer_reading = mileage
22 
23     def increment_odometer(self, miles):
24         """将里程表读数增加指定的量"""
25         self.odometer_reading  = miles
26 
27 class ElectricCar(Car):
28     """电动汽车的独特之处"""
29     def __init__(self, make, model, year):
30         """初始化父类的属性,再初始化电动汽车特有的属性"""
31         super().__init__(make, model, year)
32         self.battery_size = 80
33 
34     def describe_battery(self):
35         """打印一条描述电瓶容量的消息"""
36         print("This car has a "   str(self.battery_size)   "-kWh battery.")
37 
38 my_tesla = ElectricCar('tesla', 'model s', 2018)
39 print(my_tesla.get_descriptive_name())
40 my_tesla.describe_battery()

  说明:

  第32行,初始化电动汽车特有的属性,将其初始化为80。

  第34~36行,使用关键字def定义一个describe_battery()方法来显示电动汽车的电瓶容量大小。

  第40行,调用电动汽车特有的属性的显示方法。

 

  运行结果:

1 2018 Tesla Model S
2 This car has a 80-kWh battery.

 

本文由67677新澳门手机版发布于计算机编程,转载请注明出处:67677新澳门手机版:类与对象

关键词: