python基础(六)、类的创建和调用方式
目录
1、创建和使用类
1、创建
2、根据类创建实例
1、访问属性
2、调用方法
3、创建多个实例
2、使用类和实例
1、给属性指定默认值
2、修改属性的值
1、直接修改属性的类
2、通过方法修改属性的值
3、通过方法对属性的值进行递增
3、继承
1、子类的方法 __init__( )
2、Python2.7中的继承
3、给子类定义属性和方法
4、重写父类的方法
4、将实例用作属性
4、导入类
1、导入单个类
2、在一个模块中存储多个类
3、从一个模块中导入多类
4、导入整个模块
5、导入模块中的所有类
6、在一个模块中导入另一个模块
7、自定义工作流程
5、python标准库
1、创建和使用类
1、创建
使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类Dog------它表示的不是特定的小狗，而是任何小狗。对大多数宠物狗，我们都知道些什么呢？它们都有名字和年龄；我们还知道，大多数小狗还会蹲下和打滚。由于大多数小狗都具备上述两项信息(名字和年龄)和两种行为(蹲下和打滚)，我们的Dog类将包含它们。这个类让python知道如何创建表示小狗的对象。编写这个类后，将使用它来创建表示特定小狗的实例。
根据约定，在python中，首字母大写的名称指的是类。这个类定义中的括号是空的，因为我们要从空白创建这个类。像这样可以通过实例访问的变量称为属性。
dog.py
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!")__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，python都会自动运行它。在这个方法中，开头和末尾各有两个下划线，这是一种约定，旨在避免python默认方法与普通方法发生名称冲突。__init__()包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参前面。
为何必须在方法中包含形参self呢？
因为python调用这个，__init__()方法来创建Dog()时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。创建Dog实例时，python将调用Dog类的方法__init__()。将通过实参向Dog()传递名字和年龄；self会自动传递，因此不需要传递它。每当我们根据类创建实例时，都只需给最后两个形参(name和age)提供值。
接下来定义两个变量都有前缀self。以self为前缀的变量都可供类中的所有方法使用，还可以通过类的任何实例类访问这些变量。self.name = name获取存储在形参中的值，并将其存储到变量name中，然后该变量被关联到当前创建的实例。self.age = age的作用与此类似。像这样可通过实例访问的变量称为属性。
在Python2.7 中创建类时，需要做的修改为------在括号内包含单词object。
Class ClassName( object ):
--snip--这让Python2.7类的行为更像Python 3类，从而简化了你的工作。
在Python 2.7中定义Dog类时，代码类似于下面这样：
Class Dog(object):
--snip--
2、根据类创建实例
可将类视为有关如何创建实例的说明。Dog类是一系列说明，让python知道如何创建表示特定小狗的实例。
下面来创建一个表示特定小狗的实例：
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.")这里使用的是前一个示例中编写的Dog类。首先使用python创建一条名字为'willie'年龄为6的小狗。遇到这行代码时,python使用实参'willie'和6调用Dog类中的方法__init__()。方法__init__()创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name和age。方法__init__()并未显式地包含return语句，但python自动返回一个表示这条小狗的实例。将这个实例存储在变量my_dog中。
1、访问属性
要访问实例的属性，可使用句点表示法。接下来编写了如下代码来访问my_dog的属性name的值：
ma_dog.name句点表示法在python中很常用，这种语法演示了python如何获悉属性的值。在这里。python先找到实例my_dog，在查找与这个实例相关联的属性name。在Dog类中引用这个属性时，使用的是self.name。接下来使用同样的方法来获取属性age的值。在前面
的第1条print语句中，my_dog.name.title()将my_dog的属性name的值’willie‘改为首字母大写的；在第2条print语句中。str(my_dog.age)将my_dog的属性age的属性的值6转换为字符串。
输出是有关my_dog的摘要：
My dog's name is willie.
My dog is 6 years old.
2、调用方法
根据Dog类创建实例后，就可以使用句点表示法来调用Dog类中定义的任何方法。下面来让小狗蹲下和打滚：
class Dog():
--snip--
my_dog = Dog('willie', 6)要调用方法，可指定实例的名称(这里是my_dogs)和要调用的方法，并用句点分隔它们。遇到代码my_dog.sit()，python在类Dog中查找方法sit()并运行其代码。python以同样的方式解读代码my_dog.roll_over()。
Willie按我们的命令做了：
Willie is now sitting.
Willie rolled over!
这种语法很有用。如果给属性和方法指定了合适的描述性名称，如name、age、sit()和roll_over()。即使是从未见过的代码块，也能够轻松地推断出它是做什么的。
3、创建多个实例
可按需求根据类创建任意数量的实例。下面再创建一个名为your_dog的实例：
class Dog():
--snip--
my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
my_dog.sit()
print("\nYour dog's name is " + your_dog.name.title() + ".")
print("Your dog is " + str(your_dog.age) + " years old.")
your_dog.sit()在这个实例中，创建了两条小狗，它们分别名为Willie和Lucy。每条小狗都是一个独立的实例，有自己的一组属性，能够执行相同的操作：
My dog's name is Willie.
My dog is 6 years old.
Willie is now string.
Your dog's name is Lucy.
Your dog is 3 years old.
Lucy is now sitting.
就算给第二条小狗指定同样的名字和年两，python依然会根据Dog类创建另一个实例。你可按需求根据一个类创建任意数量的实例，条件是将每个实例都存储在不同的变量中，或占用列表或字典的不同位置。
2、使用类和实例
你可以使用类来模拟现实世界中的很多情景。类编写好后，你的大部分时间都将花在使用根据类创建的实例上。你需要执行的一个重要任务是修改实例的属性。你可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。
下面类编写一个表示汽车的类，它存储了有关汽车的信息，还有一个汇总这些信息的方法：
car.py
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.make
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())开始定义了方法__init__()。与前面的Dog类中一样，这个方法的第一个形参为self，还在这个方法中包含了另外三个形参：make、model和year。方法__init__()接受这些形参的值，并将它们存储在根据这个类创建的实例的属性中。创建新的Car实例时，需要指定其制造商、型号和生产年份。
接下来，定义了一个名为get_descriptive_neme()的方法，它使用属性year、make和model创建一个对汽车进行描述的字符串，让我们无需分别打印每个属性的值。为了这个方法中访问属性的值，使用了self.make、self.model和self.year。根据Car类创建了一个实例，并存储到变量my_new_car中。接下来，调用方法get_descriptive_name()，指出我们拥有的是一辆什么样的汽车：
2016 Audi A4
为让这个类更有趣，下面给它添加一个随时间变化的属性，它存储汽车的总里程。
1、给属性指定默认值
类中的每个属性都必须有初始值，哪怕这个值是0或者空字符串。在有些情况下，如果设置默认值时，在方法__init__()内指定这种初始值是可行的；如果你对某个属性这么做了，就无需包含为它提供初始值的形参。
下面来添加一个名为odometer_reading的属性，其初始值总是为0。还添加了一个名为read_odometer()的方法，用于读取汽车的里程表：
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_odmeter(self):
""""打印一条指出汽车里程的消息"""
print("This car has " + str(self.odometer_reading) + " miles on it.")
my_new_car = Car('audi', 'ad', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()现在，当python调用方法__init__()来创建实例时，将像前一个示例一样以属性的方法存储制造商、型号和生产年份。接下来，python将创建一个名为odometer_reading的属性，并将其初始值设置为0。接下来，我们还定义了一个名为read_odometer()的方法，它让你能够轻松地获悉汽车的里程。
一开始汽车的里程为0：
2016 Audi A4
This car has 0 miles on it.
出售时里程表读数为0的汽车并不多，因此需要一个修改该属性的值的途径。
2、修改属性的值
可以以三种不同的方法修改属性的值：
- 直接通过实例进行修改
- 通过方法进行设置
- 通过方法进行递增(增加特定的值)
1、直接修改属性的类
要修改属性的值，最简单的方法是通过实例直接访问它。下面的代码直接将里程表读数设置为23：
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.reading_odometer()使用句点表示法来直接访问并设置汽车的属性odometer_reading。这行代码让python在实例my_new_cat中找到属性odometer_reading，并将属性的值设置为23：
2016 Audi A4
This car has 23 miles on it.
有时候需要像这样直接访问属性，但其他时候需要编写对属性进行更新的方法。
2、通过方法修改属性的值
如果有替你更新属性的方法，将大有裨益。这样你就无需直接访问属性。而可将值传递给一个方法，由它在内部进行更新。
下面实例演示了一个名为update_odometer()的方法：
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.reading_odometer()对Car类所做的唯一修改是添加方法update_odometer()。这个方法接受一个里程值，并将其存储到self.odometer_reading中。接下来，调用update_odometer()，并向它提供了实参23。(该实参对应于方法定义中的形参mileage)。它将里程表读数设置为23；而方法read_odometer()打印该读书：
2016 Audi A4
This car has 23 miles on it.
可对方法update_odometer()进行扩展，使其在修改里程表读数时做些额外的工作。下面加一些逻辑，禁止任何人将里程表读数回调：
class Car():
--snip--
def update_odometer(self, mileage):
"""
将里程表读数设置为指定的值
禁止将里程表读数往回调
"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")现在，update_odometer()在修改属性前检查指定的读数是否合理。如果新指定的里程(mileage)大于或等于原来的里程(self.odometer_reading)，就将里程表读数改为新指定的里程；否则就发出警告，指出不能将里程表往回拨。
3、通过方法对属性的值进行递增
有时候需要将属性值递增，而不是将其设置为全新的值。假设购买了一辆二手车，且从购买到登记期间增加了100英里的里程，下面的方法让我们能够传递这个增量，并相应地增加了里程表读数：
class Car():
--snip--
def update_odometer(self, mileage):
--snip--
def increment_odometer(self, miles):
"""将里程表读数增加指定的量"""
self.odometer_reading += miles
my_used_car = Car('subarar', 'outback', 2013)
print(my_used_car.get_description_name())
my_used_car.update_odometer(23500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()
新增的方法increment_odometer()接受一个单位为英里的数字，并将其加入到self.odometer_reading中。接下来创建了一辆二手车------my_used_car。接下来，调用方法update_odometer()并传入23500，将这辆二手车的里程表读数设置为23500。接下来调用increment_odometer()并传入100，以增加从购买到登记期间行使的100英里：
2013 Subaru Outback.
This car has 23500 miles on it.
This car has 23600 miles on it.
你可以轻松地修改这个方法，以禁止增量为负值，从而防止有人利用它来
可以使用类似上面的方法来控制用户修改属性值(如：里程表读取)的方式。但能够访问程序的人都可以通过直接访问属性来将里程表修改为任何值。要确保安全，除了进行类似前面的基本检查外，还需特别注意细节。
3、继承
编写类时，并非总是要从空白开始。如果你编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
1、子类的方法 __init__( )
创建子类的实例时，python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法_init_( )需要父类施以援手。
例：
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_odmeter(self, miles):
self.odometer_reading += miles
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.")
def get_range(self):
"""打印一条描述电瓶续航里程的消息"""
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = "This car can go approximately " + str(range)
message += " miles on a full change."
print(message)
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())
Output:
--------------------
2016 Tesla Model S
--------------------创建子类时，父类必须包含在当前文件中，并且于子类前面。接下来定义了子类ElectricCar。定义子类时，必须在括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息。定义子类时，必须在括号内指定父类的名称。super()是一个特殊函数，帮助python将子类和父类关联起来。这行代码让python调用ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类所有属性。父类也称为超类(superclass)，名称super因此而得名。
为测试继承是否能够正确地发挥作用，尝试创建一辆电动汽车，但提供的信息与创建普通汽车时相同。接下来，创建ElectricCar类的一个实例，并将其存储在变量my_tesla中。这行代码调用ElectricCar类中定义的方法__init__()，后者让python调用父类Car中定义的方法__init__()。提供了实参'tesla'，'model s'和2016。
除方法__init__()外，电动汽车没有其他特有的属性和方法。当前，只想确认电动汽车具备普通汽车的行为。
ElectricCar实例的行为与Car实例一样，现在可以开始定义电动汽车特有的属性和方法了。
2、Python2.7中的继承
在python2.7中，继承语法稍有不同，ElectricCar类的定义类似于下面这样：
Class Car(object):
def __init__(self, make, model, year):
--snip--
class ElectricCar(Car):
def __init__(self, make, model, year):
super(Electric, self).__init__(make, model, year)
--snip--函数super()需要两个实参：子类名和对象self。为帮助python将父类和子类关联起来，这些实参必不可少。另外，在python2.7中使用继承时，务必在定义父类时在括号内指定object。
3、给子类定义属性和方法
让一个类定义另一个类后，可添加区分子类和父类所需的新属性和方法。
下面来添加一个电动汽车特有的属性(电瓶)，以及一个描述属性的方法。我们将存储电瓶容量，并编写一个打印电瓶描述的方法：
"""一个可用于表示汽车的类"""
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_odmeter(self, miles):
self.odometer_reading += miles
class ElectricCar(Car):
"""模拟电动汽车的独特之处"""
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.battery.describe_battery()
Output:
-------------------------------
2016 Tesla Model S
This car has a 70-kWh battery.
-------------------------------添加了新属性self.battery_size，并设置其初始值(如70)。根据ElectricCar类创建的所有实例都包含这个属性，但所有Car实例都不包含它。接下来还添加了宇哥名为describe_battery()的方法，它打印有关电瓶的信息。调用这个方法时，将看到一条电动车特有的描述。对于ElectricCar类的特殊化程度没有任何限制，模拟电动汽车时，你可以根据所需的准确程度添加任意数量的属性和方法。如果一个属性和方法是任何汽车都有的，而不是电动汽车特有的，就应该将其加入到Car类而不是ElectricCar类中。这样，使用Car类的人将获得相应的功能，而ElecricCar类只包含处理电动汽车特有属性和行为的代码。
4、重写父类的方法
对于父类的方法，只要它不符合子类模块的实物的行为，都可以对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，python将不会考虑这个父类方法，而只关注你在子类中定义的响应方法。假设Car类有一个名为fill_gas_tank()的方法，它对全电动汽车来说毫无意义，因此你可能想重写它。下面演示了一种重写方式：
class ElectricCar(Car):
--snip--
def fill_gas_tank(self):
"""电动汽车没有油箱"""
print("This car doesn't need a gas tank!")现在，如果有人对电动汽车调用方法fill_gas_tank()，python将忽略Car类中的方法fill_gas_tank()，转而运行上述代码。使用继承时，可让子类保留从父类那里继承而来的精华，并剔除不需要的糟粕。
4、将实例用作属性
使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。你可以将大型类拆成多个协同工作的小类。例如，不断给ElectricCar类添加细节，可能会发现其中包含很多专门针对汽车电瓶的属性和方法。在这种情况下，可将这些属性和方法提取出来，放到另一个名为Battery的类中，并将一个Battery实例用作ElectricCar类的一个属性：
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_odmeter(self, miles):
self.odometer_reading += miles
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()
Output:
-------------------------------
2016 Tesla Model S
This car has a 70-kWh battery.
-------------------------------首先定义了一个名为Battery的新类，它没有继承任何类。接下来的方法__init__()除self外，还有另一个形参battery_size。这个形参是可选的：如果没有给它提供值，电瓶容量将被设置为70。方法describe_battery()也移到了这个类中。在ElectricCar类中，添加了一个名为self.battery的属性。这行代码让python创建一个新的Battery实例(由于没有指定尺寸，因此为默认值70)，并将该实例存储在属性self.battery中。每当方法__init__()被调用时，都将执行该操作；因此现在每个ElectricCar实例都包含一个自动创建的Battery实例。创建一辆电动汽车，并将其存储在变量my_tesla中。要描述电瓶时，需要使用电动汽车的属性battery：
my_tesla.battery.describe_battery()
这行代码让python在实例my_tesla中查找属性battery，并对存储在该属性中的Battery实例调用方法describe_battery()。这看似做了很多额外的工作，但现在想多详细地描述电瓶都可以，且不会导致，ElectricCar类混乱不堪。下面再给Battery类天健一个方法，它根据电瓶容量报告汽车的续行里程：
class Car():
--snip--
class Battery():
---snip--
def get_range(self):
"""打印一条消息，提出电瓶的续行里程"""
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = "This car can go approximately " + str(range)
message += "miles on a full charge."
print(message)
class ElectricCar(Car):
--snip--
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
Output:
----------------------------------------------------------
2016 Tesla Model S
This car has a 70 -kWh battery.
This car can go approximately 240 miles on a full charge.
----------------------------------------------------------对开始新增的方法get_range()做了一些简单的分析：如果电瓶的容量为70kWh，它就将续行里程设置为240英里；如果容量为85kWh，就将续航里程设置为270英里，然后报告这个值。为使用这个方法，也通过汽车的属性battery来调用它。输出指出了汽车的续行里程(这取决于电瓶的容量)。
4、导入类
随着你不断地给类添加功能，文件可能变得很长，即使你妥善地使用了继承，亦如此。为遵循python的总体理念，应让文件尽可能整洁。为这方面提供帮助，python允许你将类存储在模块中，然后在主程序中导入所需的模块。
1、导入单个类
下面来创建一个只包含Car类的模块。这面临一个微妙的命名问题：前面已经有一个名为car.py的文件，但这个模块也应命名为car.py，因为它包含表示汽车的代码。将这样解决这个命名问题：Cat类存储在一个名为car.py的模块中，该模块将覆盖前面使用的文件car.py。从现在开始，使用该模块的程序都必须使用更具体的文件名，比如my_car.py。下面是模块car.py，其中只包含Car类的代码：
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_odmeter(self, miles):
self.odometer_reading += miles开始包含了一个模块级文档字符串，对该模块的内容做了简单的描述。你应为自己创建的每个模块都编写字符文档。下面创建一个文件------my_car.py，在其中导入Car类并创建其实例：
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()
Output:
------------------------------
2016 Audi A4
This car has 23 miles on it.
------------------------------
import语句让python打开模块car，并导入其中的Car类。这样就可以使用Car类了，就像它是在这个文件中定义的一样。导入类是一种有效的编程方式。如果在这个文件中包含了整个Car类，程序变得非常长。通过将这个类移到一个模块中，并导入该模块，你依然可以使用其所有功能，但主程序文件变得整洁而易于阅读了。这还能让你将大部分逻辑存储在独立的文件中；确定类像你希望的那样工作后，你就可以不管这些文件，而专注于主程序的高级逻辑了。
2、在一个模块中存储多个类
虽然同一个模块中的类之间应存在某种相关性，但可根据需要在一个模块中存储任意数量的类。类Battery和ElectricCar都可帮助模拟汽车，因此下面将它们都加入模块car.py中：
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_odmeter(self, miles):
self.odometer_reading += miles
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.")
def get_range(self):
"""打印一条描述电瓶续航里程的消息"""
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = "This car can go approximately " + str(range)
message += " miles on a full change."
print(message)
class ElectricCar(Car):
"""模拟电动汽车的独特之处"""
def __init__(self, make, model, year):
"""
初始化父类的属性，在初始化电动车的属性
"""
super().__init__(make, model, year)
self.battery = Battery()现在，可以创建一个名为my_electric_car.py的文件，导入ElectricCar类，并创建一辆电动汽车了：
my_electric_car.py
from car import ElectricCar
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
Output:
------------------------------------------------------------
2016 Tesla Model S
This car has a 70-kWh battery.
This car can go approximately 240 miles on a full change.
------------------------------------------------------------输出与我们前面看到的相同，但大部分逻辑隐藏在一个模块中。
3、从一个模块中导入多类
可根据需要在程序文件中导入任意数量的类。如果要在同一个程序中创建普通汽车和电动汽车，就需要将Car和ElectricCar类都导入：
my_cars.py
from car import Car, ElectricCar
my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())
Output:
------------------------
2016 Volkswagen Beetle
2016 Tesla Roadster
------------------------开始从一个模块中导入多个类时，用逗号分隔了各个类。导入必要的类后，就可根据需要创建每个类的任意数量的实例。这个示例创建了一辆大众甲壳虫普通汽车和一辆特斯拉Roadster电动汽车。
4、导入整个模块
你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入的方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此也不会与当前的文件使用的任何名称发生冲突，开始就导入整个car模块。下面的代码导入整个car模块，并创建一辆普通电动汽车：
my_cars.py
import car
my_beetle = car.Car('volkwagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name( ))
my_tesla = car.ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())
Output:
-----------------------
2016 Volkwagen Beetle
2016 Tesla Roadster
-----------------------我们导入了整个car模块。接下来，我们使用语法module_name.class_name访问需要的类。像前面一样，创建一辆大众甲壳虫汽车和特斯拉Roadster汽车。
5、导入模块中的所有类
要导入模块中的每个类，可使用下面的语法：
from module_name import * 不推荐使用这种导入方式，其原因有二。首先，如果只要看一下文件开头的import语句，就能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出你使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐使用这种方式，但你可能会在别人编写的代码中见到它。
需要从一个模块中导入很多类时，最好导入这个模块，并使用module_name.class_name语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块；你还避免了导入模块中的每个类可能引发的命名冲突。
6、在一个模块中导入另一个模块
有时候，需要将类分散到多个模块中，以免模块太大，或在同意模块中存储不相关的类。将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。例如，下面将Car类存储在一个模块中，并将ElectricCar和Battery类存储在另一个模块中。将第二个模块命名为eletric_car.py(这将覆盖前面创建的文件electric_car.py)，并将Battery和ElectricCar类复制到这个模块中：
electric_car.py
"""一组可用于表示电动汽车的类"""
from car import Car
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.")
def get_range(self):
"""打印一条描述电瓶续航里程的消息"""
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = "This car can go approximately " + str(range)
message += " miles on a full change."
print(message)
class ElectricCar(Car):
"""模拟电动汽车的独特之处"""
def __init__(self, make, model, year):
"""
初始化父类的属性，在初始化电动车的属性
"""
super().__init__(make, model, year)
self.battery = Battery()ElectricCar类需要访问其父类Car，因此在开始，直接将Car类导入该模块中。如果我们忘记了这行代码，python将在我们试图创建ElectricCar实例时引发错误。我们还需要重新更新模块car，使其包含Car类：
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_odmeter(self, miles):
self.odometer_reading += miles现在可以分别从每个模块中导入类，以根据需要创建任何类型的汽车了：
my_cars.py
from car import Car
from eletric_car import ElectricCar
my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())
Output:
-----------------------
2016 Volkswagen Beetle
2016 Tesla Roadster
-----------------------开始从模块car类中导入了Car类，并从模块electric_car中导入ElectricCar类。接下来，创建了一辆普通汽车和一辆电动汽车。这两种汽车都得以正确地创建。
7、自定义工作流程
正如你看到的，在组织大型项目代码方面，Python提供了很多选项，熟悉所有这些选项很重要，这样你才能确定哪种项目是最佳的，并能理解别人开发的项目。开始应让代码结构尽可能简单，尽可能现在一个文件中完成所有的工作，确定一切都能正常运行后，再将类移到独立的模块中。如果你喜欢模块和文件的交互方式，可在项目开始就尝试将类存储到模块中。先找出让你能够编写出可行代码的方式，再尝试让代码更为组织有序。
5、python标准库
python标准库是一组模块，安装的python都包含它。你现在对类的工作原理已有大致的了解，可以开始使用其他程序员编写好的模块了。可使用标准库中的任何函数和类，为此只需在程序开头包含一条简单的import语句。下面来看模块import语句。下面来看模块collections中的一个类------OrderedDict。
字典让你能够将信息关联起来，但它们不记录你添加键-值对的顺序。要创建字典并记录其中的键-值对的顺序。要创建字典并记录其中的键-值对的添加顺序，可使用模块collections中的OrderedDict类。OrderedDict实例的行为顺序：
favorite_languages.py
from colections import OederedDict
favorite_languages = OrderedDict()
favorite_languages['jen'] = 'python'
favorite_languages['sarah'] = 'c'
favorite_languages['edward'] = 'ruby'
favorite_languages['phil'] = 'python'
for name, language in favorite_language.items():
print(name.title() + "'s favorite language is " +
language.title() + ".")首先从模块collection中导入了OrderedDict类。然后创建了OrderedDict类的一个实例，并将其存储到favorite_languages中。请注意，这里没有使用花括号而是调用OrderedDict()来创建一个空的有序字典，并将其存储在favorite_languages中。接下来，以每次一对的方式添加名字-语言对。最后遍历favorite_languages，但知道将以添加的顺序获取调查局结果：
Jen's favorite languages is Python.
Sarah's favorite languages is C.
Edward's favorite language is Ruby.
Phil's favorite language is Python.
这是一个不错的类，它间距列表和字典的主要优点(在将信息关联起来的同时保存原来的顺序)。等你开始对关心的现实情形建模时，可能会发现有序字典正好能够满足需求。随着你对标准库的了解越来越深入，将熟悉大量可帮助你处理常见情形的模块。