首页 > > 网络编程 > 其它 >

Python 类

2018-08-17 09:47:03来源：博客园阅读 ()

一、类简介

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.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，相当于指定了默认值

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

2.直接修改属性的值

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

1 my_car.odometer_reading = 23

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! ")

三、继承

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

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)

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允许将类存储在模块中，然后在主程序中导入所需的模块

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

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

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

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

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

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

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

五、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()+'.')