当前位置：&&&&&&&&&
华为mate8和mateS有什么区别 听说美腿要超越苹果
来源：深窗综合&|& 09:00&编辑：小六
前天，华为发布了一款千元机荣耀5X，如今华为的年度旗舰机华为mate8也有了新的消息，余承东向媒体透露，自己已经用上了这款手机，它在屏幕和拍照上十分出色。而对于外界有传言Mate 8跳票，他也重申，Mate8因为要等麒麟950处理器，所以晚了一点，但肯定是在年内。那么这款华为mate8和mates有什么区别呢？
首先我们来回顾一下华为mateS的配置情况，华为MateS采用一体化全金属设计，使用了一块1080P分辨率的5.5英寸屏幕，该机搭载麒麟935处理器，内置3GB运行内存和32GB/64GB本地存储空间(支持扩展)，摄像头为前置500万+后置1300万像素的组合(支持光学防抖)，配有2700mAh，容量电池，支持双卡双待。
至于华为mate8方面，余承东表示Mate S（5.5寸）将会与Mate 8组成一小一大的产品组合。之前曾有消息称，Mate 8屏幕会是6寸。从余承东的发言来看，应该就是这样了。其他配置方面，华为Mate8搭载麒麟950，支持压力感应，依然采用全金属机身设计，并配备超大容量电池，同时提供前置800万摄像头和后置2000万摄像头。
余承东还强调，在高端旗舰上，华为走的的确比较辛苦，但他们是在真正的用产品去挑战、并超越苹果，比如即将到来的Mate 8，他对此很有信心。
对于今年的目标，华为手机要突破1亿台。
PS：Mate S死磕iPhone 6S，而Mate 8是一款超越苹果的作品....
的相关阅读:
窗花有话说
网友评论仅供其表达个人看法，并不表明深窗立场。
深窗公众平台平板/笔记本
终端云服务专区
请问美腿八，它的最大支持的扩展容量是多少？
&渐入佳境&
来自：华为Mate8 NXT-AL10
如题。另外想问问大家闪迪的，白卡和红卡有什么区别？
width:100%">
&已臻大成&
来自：华为Mate8 NXT-AL10
百度搜索一下不就知道了
width:100%">
&渐入佳境&
来自：华为Mate8 NXT-AL10
莫忘缘份1 发表于
百度搜索一下不就知道了
谢谢啊，百度搜索，我不会用。?(^?^*)
width:100%">
&花粉版主&
来自：浏览器
最高支持128g的sd卡，这个官网有说明
大家有问题发帖提就是，版主们和热心花粉都会响应的~如果比较急，可以@wnsfl，谢谢
width:100%">
&已臻大成&
来自：华为Mate8 NXT-AL10
苦丁子 发表于
谢谢啊，百度搜索，我不会用。?(^?^*)
别再说笑好不好？会用手机的，哪能不会用百度呢
width:100%">
&自成一派&
来自：华为Mate9 Pro LON-AL00
我用128的闪迪！
width:100%">
&登堂入室&
来自：HUAWEI NXT-CL00
width:100%">
&初窥门径&
来自：浏览器
百度搜索一下不就知道了!
width:100%">
&花粉版主&
来自：华为Mate8 NXT-AL10
width:100%">
&渐入佳境&
来自：华为Mate8 NXT-AL10
莫忘缘份1 发表于
别再说笑好不好？会用手机的，哪能不会用百度呢
就是不会啊，不用百度。
width:100%">
大富翁勋章
达到1万花瓣后可申请获得大富翁勋章
在职斑竹的身份勋章，感谢斑竹的辛勤劳动
1000万花粉
纪念花粉俱乐部注册花粉数超过1000万
好基友勋章
花粉好机友，注册时间大于99天
关注华为花粉俱乐部微信公众平台——“华为花粉俱乐部”
我家住在黄土高坡家有小女【夜赏艺术中心】【花粉随手拍】雪中小景古塔四季飞 雪 阅 江 楼
花粉客户端
Make it Possible
Make your device special
华为云服务
Huawei cloud services
音乐播放器
Huawei Music
Huawei Vmall
关注花粉俱乐部
举报邮箱：
|关注花粉俱乐部：
Copyright (C)
华为软件技术有限公司 版权所有 保留一切权利今天看啥 热点：
第 9 章 类，美腿校花戴若曦第9章&&& 面向对象编程是最有效的软件编写方法之一。在面向对象编程中，我们编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编写类时，我
们定义一大类对象都有的通用行为。基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。使用面向对象编程可模拟
现实情景，其逼真程度达到了令人惊讶的地步。
&&& 根据类来创建对象被称为实例化，这让我们能够使用类的实例。在本章中，我们将编写一些类并创建其实例。我们将指定可在实例中存储什么信息，定义可对这些实例执行哪些操作。我们还将编写一些类来扩展自己的程序文件中导入其他程序员编写的类。
&&& 理解面向对象编程有助于我们像程序员那样看世界，还可以帮助我们真正明白自己编写的代码：不仅是各行代码的作用，还有代码背后更宏大的概念。了解类
背后的概念可培养逻辑思维，让我们能够通过编写程序来解决遇到的几乎任何问题。
&&& 随着面临的挑战日益严峻，类还能让我们以及与我们合作的其他程序员的生活更轻松。如果我们与其他程序员基于同样的逻辑来编写代码，我们就能明白对方所做的工作；我们编写的程序将能被众多合作者所理解，每个人都能事半功倍。
9.1& 创建和使用类
&&& 使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类Dog——它表示的不是特定的小狗，而是任何小狗。对于大多数宠物狗，我们都知道些什么呢？它们都有自己的名字和年龄；我们还知道，大多数小狗还会蹲下和打滚。由于大多数小狗都具备上述两项信息（名字和年龄）和两种行为（蹲下和打滚），我们的Dog类将包含它们。这个类让Python知道如何创建表示小狗的对象，编写这个类后，我们将使用它来创建表示特定小狗的实例。
&&& 类就是把一类具有共同属性的事物封装到一起，不用重复编写这些程序，编写好类后，需要的时候只需调用相应的类即可。
9.1.1& 创建Dog类
&&& 根据Dog类创建的每个实例都将存储名字和年龄。我们赋予了每条小狗蹲下（sit())和打滚(roll_over())的能力：
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!")
这里需要注意的地方很多，但我们也不用担心，本章充斥着这样的结构，我们有大把的机会熟悉它。在(1)处，我们定义了一个名为Dog的类。根据约定，在Python中，首字母大写的名称指的是类。这个类定义中的括号是空的，因为我们要从空白创建这个类。在(2)处，我们编写了一个文档字符串，对这个类的功能做了描述。
1、方法__init__()
类中的函数称为方法；我们前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。(3)处的方法__init__()是一个特殊的方法，每当我们根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
我们将方法__init__()定义成了包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参前面。为何必须包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。我们创建Dog实例时，Python将调用Dog类的方法__init__()。我们将通过实参向Dog()传递名字和年龄，self会自动传递，因此我们不需要传递它。每当我们根据Dog类创建实例时，都只需给最后两个形参(name和age）提供值。
(4)处定义的两个变量都有前缀self。以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。selfname =name 获取存储在形参name中的值，并将其存储到变量name中， 然后该变量被关联到当前创建的实例。selfage = age的作用与此类似。像这样可通过实例访问的变量称为属性。
Dog类还定义了另外两个方法：sit()和roll_over()。由于这些方法不需要额外的信息，如名字或年龄，因此它们只有一个形参self。我们后面将创建的实例能够访问这些方法，换句话说，它们都会蹲下和打滚。但可以扩展这些方法以模拟实际情况：如果这个类包含在一个计算机游戏中，这些方法将包含创建小狗蹲下和打滚动画效果的代码。如果这个类是用于控制机器狗的，这些方法将引导机器狗做出蹲下和打滚的动作。
2.在Python2.7中创建类
在Python2.7中创建类时，需要做出细微的修改——在括号中包含单词object：
class ClassName(object):
这让Python2.7类的行为更像Python3类，从而简化了我们的工作：
在Python2.7中定义Dog类，代码类似于下面这样：
class Dog(object):9.1.2
根据类创建实例
可将类视为有关如何创建实例的说明。Dog类是一系列说明，让Python知道如何创建表示特定小狗的实例。
下面来创建一个表示特定小狗的实例：
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!")my_dog = Dog('willie',6)
——（1）print("My dog's name is " + my_dog.name.title() + ".")
——（2）print("My dog is " + str(my_dog.age) + ' years old.')
这里使用的是前一个示例中编写的Dog类。在(1)处，我们让Python创建一条名字为'willie'、年龄为6的小狗。遇到这行代码时，Python使用实参'willie'和6调用Dog类中的方法__init__().方法__init__()并未先式地包含return语句，但Python自动返回一个表示小狗的实例。我们将这个实例存储在变量my_dog中。在这里，命名约定很有用：我们通常可以认为首字母大写的名称(如Dog)指的是类，而小写的名称(如my_dog)指的是根据类创建的实例。
1.访问属性
要访问实例的属性，可使用句点表示法。在(2)处，我们编写了如下代码来访问my_dog的属性name的值：
my_dog.name
句点表示法在Python中很常用，这种语法演示了Python如何获悉属性的值。在这里，Python先找到实例my_dog，再查找与这个实例相关联的属性name.在Dog类中引用这个属性时，使用的是self.name。在(3)处，我们使用同样的方法来获取属性age的值。在前面的第一条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类中定义的任何方法。下面来让小狗蹲下和打滚：
my_dog = Dog('willie',6)
my_dog.sit()my_dog.roll_over()
要调用方法，可指定实例的名称(这里是my_dog)和要调用的方法，并用句点分隔它们。遇到代码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():
"""一次模拟小狗的简单尝试"""
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!")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.roll_over()
在这个实例中，我们创建了两条小狗，它们分别名为Willie和Lucy。每条小狗都是一个独立的实例，有自己的一组属性，能够执行相同的操作：My dog's name is Willie.My dog is 6 years old.Willie is now sitting.Your dog's name is Lucy.Your dog is 3 years old.Lucy rolled over!
就算我们给第二条小狗同样的名字和年龄，Python依然会根据Dog类创建另一个实例。我们可按需求根据一个类创建任意数量的实例，条件是将每个实例都存储在不同的变量中，或占用列表或字典的不同位置。动手试一试
9-1 餐馆：创建一个名为Restaurant的类，其方法__init__()设置两个属性：restaurant_name和cuisine_type.创建一个名为describe_restaurant()的方法和一个名为open_restaurant()的方法，其中前者打印前述两项信息，而后者打印一条消息，指出餐馆正在营业。
class Restaurant():
"""模拟餐馆营业的情况"""
def __init__(self,restaurant_name,cuisine_type):
"""初始化属性restaurant_name和cuisine_type"""
self.restaurant_name
= restaurant_name
self.cuisine_type = cuisine_type
def describe_restaurant(self):
'''模拟餐馆的基本信息'''
print(self.restaurant_name.title())
print(self.cuisine_type)
def open_restaruant(self):
print('The restaurant is opening.')restaurant = Restaurant("xiangtata","Western-style food")print("The restaurant's name is " + restaurant.restaurant_name.title() + ".")print("The restaurant is good at " + restaurant.cuisine_type + ".")restaurant.describe_restaurant()restaurant.open_restaruant()运行结果如下：The restaurant's name is Xiangtata.The restaurant is good at Western-style food.XiangtataWestern-style foodThe restaurant is opening.
9-3 用户：创建一个名为User的类，其中包含属性first_name和last_name，还有用户简介通常会存储的其他几个属性。在User中定义一个名为describe_user()的方法，它打印用户信息摘要；再定义一个名为greet_user()的方法，它向用户发出个性化的问候。
创建多个表示不同用户的实例，并对每个实例都调用上述方法。
class User():
'''模拟描述用户基本信息'''
def __init__(self,first_name,last_name,age,sex):
'''初始化用户基本信息'''
self.first_name = first_name
self.last_name = last_name
self.age = age
self.sex = sex
def describe_user(self):
'''描述用户的基本信息'''
full_name = self.first_name + self.last_name
print("\nMy name is " + full_name.title() + ".")
print("My sex is " + self.sex + ", and I'm "+ str(self.age) + " years old." )
def greet_user(self):
"""对用户进行简单的问候"""
print("Thank for your attention," + self.first_name.title() + " " + self.last_name.title()+".")user_1 = User("zeng",'mingzhu',20,"female")user_2 = User("Geng",'chagnxue',26,'male')user_1.describe_user()user_1.greet_user()user_2.describe_user()user_2.greet_user()运行结果如下：My name is Zengmingzhu.My sex is female, and I'm 20 years old.Thank for your attention,Zeng Mingzhu.My name is Gengchagnxue.My sex is male, and I'm 26 years old.Thank for your attention,Geng Chagnxue.9.2
使用类和实例
我们可以使用类来模拟现实世界中很多情景。类编写好后，我们的大部分时间都将花在使用根据类创建的实例上。我们需要执行的一个重要任务就是修改实例的属性。我们可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。9.2.1
下面来编写一个表示汽车的类，它存储了有关汽车的信息，还有一个汇总这些信息的方法：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.model
return long_name.title()my_new_car = Car('audi','a4',2016)
——（3）print(my_new_car.get_descriptive_name())
在(1)处，我们定义了方法__init__()。与前面的Dog类中一样，这个方法的第一个形参为self；我们还在这个方法中包含了另外三个形参：make,model和year。方法__init__()接受这些形参的值，并将它们存储在根据这个类创建的实例的属性中。创建新的Car实例时，我们需要指定其制造商，型号和生产年份。
在(2)处，我们定义了一个名为greet_descriptive_name()的方法，它使用属性year、model和year创建一个对汽车进行描述的字符串，让我们无需分别打印每个属性的值。为在这个方法中访问属性的值，我们使用了self.make、self.model和self.year。在（3）处，我们根据Car类创建了一个实例，并将其存储到变量my_new_car中。接下来，我们调用方法get_descriptive_name()，指出我们拥有的是一辆什么样的汽车：
2016 Audi A4
为让这个类更有趣，下面给它添加一个随时间变化的属性，它存储汽车的总里程。9.2.2
给属性指定默认值
类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认值时，在方法__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.")my_new_car = Car('audi','a4',2016)print(my_new_car.get_descriptive_name())my_new_car.read_odometer()
现在，当Python调用方法__init__()来创建新实例时，将像前一个示例一样以属性的方式存储制造商、型号和生产年份。接下来，Python将创建一个名为odometer_reading的属性，并将其初始值设置为0.在2处，我们还定义了一个名为read_odometer()的方法，它让我们能够轻松地获悉汽车的里程。9.2.3
修改属性的值
可以以三种不同的方式修改属性的值：直接通过实例就行修改；通过方法进行设置；通过方法进行递增（增加特定的属性）。下面依次介绍这些方法：　　1.直接修改属性的值
要修改属性的值，最简单的方式是通过实例直接访问它。下面的代码直接将里程表读数设置为23：
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.")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）处，我们使用句点表示法来直接访问并设置汽车的属性odometer_reading。这行代码让Python在实例my_new_car中找到属性odometer_reading，并将该属性的值设置为23：2016 Audi A4This car has 23 miles on it.
有时候需要像这样直接访问属性，但其他时候需要编写对属性进行更新的方法。
2.通过方法修改属性的值
如果有替我们更新属性的方法，将大有裨益。这样，我们就无需直接访问属性，而可将值传递给一个方法，由它在内部进行更新。
下面的示例演示了一个名为update_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):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
self.odometer_reading = mileage
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.update_odometer(23)
--（2）my_new_car.read_odometer()
对Car类所做的唯一修改是在（1）处添加了方法update_odometer()。这个方法接受一个里程值，并将其存储到self.odometer_reading中。在（2）处，我们调用了update_odometer()，并向它提供了实参23（该实例对应于方法定义中的形参mileage)。它将里程表读数设置为23；而方法read_odometer()打印该读数：2016 Audi A4This car has 23 miles on it.
可对方法update_odometer()进行扩展，使其在修改里程表读数时做些额外的工作。下面来添加一些逻辑，禁止任何人将里程表的读数往回调：
class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
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.update_odometer(23)my_new_car.read_odometer()运行结果如下：2016 Audi A4You can't roll back on odometer!This car has 40 miles on it.
现在，update_odometer()在修改属性前检查指定的读数是否合理。如果新指定的里程(mileage)大于或等于原来的里程(self.odometer_reading)，就将里程表读数改为新指定的里程；否则就发出警告，指出不能往里程表往回调。
3.通过方法对属性的值进行递增
有时候需要将属性值递增特定的量，而不是将其设置为全新的值。假设我们购买了一辆二手车，且从购买到登记前增加了100英里的里程，下面的方法让我们能够传递这个增量，并相应地增加里程表读数：
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 update_odometer(self,mileage):
'''更新汽车里程表'''
self.odometer_reading = mileage
def increment_odometer(self,mileage):
"""将里程表读数增加指定的量"""
self.odometer_reading += mileage
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")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()
我们可以轻松地修改这个方法，以禁止增量为负值，从而防止有人利用它来回拨里程表。9.3
编写类时，并非总是要从空白开始。如果我们要编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。9.3.1
子类的方法__init__()
创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__()需要父类施以援手。
例如，下面来模拟电动汽车，电动汽车是一种特殊的汽车，因此我们可以在前面创建的Car类的基础上创建新类ElectricCar，这样我们就只需为电动汽车特有的属性和行为编写代码。
下面来创建一个简单的ElectricCar类版本，它具备Car类的所有功能：electric_car.py
class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")class ElectricCar(Car):
'''电动汽车的独特之处'''
def _init__(self,make,model,year):
"""初始化父类的属性"""
super().__init__(make,model,year)my_tesla = ElectricCar('tesla','model s',2016)name = my_tesla.get_descriptive_name()print(name)
首先是Car类的代码。创建子类时，父类必须包含在当前文件中，且位于子类前面。在2处，我们定义了子类ElectricCar。定义子类时，必须在括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息。
4处的super()是一个特殊函数，帮助Python将父类和子类关联起来，这行代码让Python调用ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。父类也称为超类(supercalss),名称super因此而得名。
为测试继承是否能够正确地发挥作用，我们尝试创建一辆电动汽车，但提供的信息与创建普通汽车时相同。在5处，我们创建ElectricCar类的一个实例，并将其存储在变量my_tesla中。这行代码调用ElectricCar类中定义的方法__init__()，后者让Python调用父类Car中定义的方法__init__()。我们提供了实参'tesla','model s'和2016.
除方法__init__()外，电动汽车没有其他特有的属性和方法。当前，我们只想确认电动汽车具备普通汽车的行为：2016 Tesla Model S
ElectricCar实例的行为与Car实例一样，现在可以开始定义电动汽车特有的属性和方法了。9.3.2
Python2.7中的继承
在Python2.7中，继承语法稍有不同，ElectricCar类的定义类似与下面这样：class Car(obiect):　　def __init__(self,make,model,year):class ElectricCar(Car):　　def __init__(self,make,model,year):　　　　super(ElectricCar,self).__init__(make,model,year)
super()函数需要两个实参：子类名和对象self。为帮助Python将父类和子类关联起来，这些实参必不可少。另外，在Python2.7中使用继承时，务必在定义父类时在括号内指定object。9.3.3
给子类定义属性和方法
让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。　　下面来添加一个电动汽车特有的属性(电瓶),以及描述该属性的方法。我们将存储电瓶容量，并编写一个打印电瓶描述的方法：
class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")class ElectricCar(Car):
'''电动汽车的独特之处'''
def __init__(self,make,model,year):
"""电动汽车的独特之处"""
'''初始化父类的属性，再初始化电动汽车特有的属性'''
super().__init__(make,model,year)
self.battery = 70
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("This car has a " + str(self.battery) + '-kwh battery.')my_tesla = ElectricCar('tesla','model s',2016)name = my_tesla.get_descriptive_name()print(name)my_tesla.describe_battery()
在1处，我们添加了新属性self.battery_size，并设置其初始值(70)，根据ElectricCar类创建的所有实例都将包含这个属性，但所有Car实例都不包含它。在2处，我们还添加了一个名为describe_battery()的方法，它打印有关电瓶的信息。我们调用这个方法时，将看到一条电动汽车特有的描述：2016 Tesla Model SThis car has a 70-kwh battery.
对于ElectricCar类的特殊话程度没有限制。模拟电动汽车时，我们可以根据所需的准确程度添加任意数量的属性和方法。如果一个属性或方法是任何汽车都有的，而不是电动汽车特有的，就应将其加入到Car类中而不是ElectricCar类中。这样，使用Car类的人将获得相应的功能，而ElectricCar类只包含处理电动汽车的特有属性和行为的代码。9.3.4
重写父类的方法
对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。
假设Car类有一个名为fill_gas_tank()的方法，它对全电动汽车来说毫无意义，因此我们可能想重写它。下面演示了一种重写的方式：
class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def fill_gas_tank(self):
print("As")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")class ElectricCar(Car):
'''电动汽车的独特之处'''
def __init__(self,make,model,year):
"""电动汽车的独特之处"""
'''初始化父类的属性，再初始化电动汽车特有的属性'''
super().__init__(make,model,year)
self.battery = 70
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("This car has a " + str(self.battery) + '-kwh battery.')
def fill_gas_tank(self):
"""电动汽车没有邮箱"""
print("This car doesn't need a gas.")my_tesla = ElectricCar('tesla','model s',2016)print(my_tesla.get_descriptive_name())my_tesla.fill_gas_tank()my_tesla.describe_battery()
现在，如果有人对电动汽车调用方法fill_gas_tank()，Python将忽略Car类中的方法fill_gas_tank()，转而运行上述代码。使用继承时，可让子类保留从父类哪里继承而来的精华，并剔除不需要的糟粕。9.3.5
将实例用作属性
使用代码模拟实物时，我们可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。我们可以将大型类拆分成多个协同工作的小类。
例如，不断给ElectricCar类添加细节时，我们可能会发现其中包含很多专门针对汽车电瓶的属性和方法。在这种情况下，我们将这些属性和方法提取出来，放到另一个名为Battery的类中，并将一个Battery实例用作ElectricCar类的一个属性：
class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")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()
在1处，我们定义了一个名为Battery的新类，它没有继承任何类。2处的方法__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().
输出与我们前面看到的相同：　　2016 Tesla Model S　　This car has a 70-kwh battery.
这看似做了很多额外的工作，但现在我们向多详细地描述电瓶都可以，且不会导致ElectricCar类混乱不堪。下面再给Battery类添加一个方法，它根据电瓶容量报告汽车的续航里程：
class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")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 charge."
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)my_tesla.battery.battery_size = 85print(my_tesla.get_descriptive_name())my_tesla.battery.describe_battery()my_tesla.battery.get_range()
（1）处新增的方法get_range()做了一些简单分析：如果电瓶的容量为70kwh,它就将续航里程设置为240英里；如果容量为85kwh，就将续航里程设置为270英里，然后报个这个值。为使用这个方法，我们也通过汽车的属性battery来调用它。
输出了汽车的续航里程(这取决于电瓶的容量):2016 Tesla Model SThis car has a 85-kwh battery.This car can go approximately 270 miles on a full charge.
在上述代码中，我修改了电池的容量，代码语句为my_tesla.battery.battery_size = 85，我也尝试了几种其他的情况，但是都不行，也就是说当我们把类赋给属性的时候，属性就拥有了类所有的性质，可以去调用，修改也是一样，要么直接在代码里面修改，要么通过这个属性才能够去修改，其他途径都是不可以的。其实类就像一所大学，你，我和他都是这个大学的学生，我们具有共同的属性，都是这个大学的学生，但我们也是彼此独立的，父类就像这所大学，子类就行我们彼此一样，所以在调用类的时候一定要指明是谁要调用这个类，调用谁的属性，要特别指明。9.3.6
模拟较复杂的物件(如电动汽车)时，需要解决一些有趣的问题。续航里程是电瓶的属性还是汽车的属性呢？如果我们只描述一辆汽车，那么将方法get_range()放在Battery类中也许是合适的；但如果要描述一家汽车制造商的整个产品线，也许应该将方法get_range()移到ElectricCar类中。在这种情况下，get_range()依然根据电瓶容量在确定续航里程，但报告的是一款汽车的续航里程。我们也可以这样做：将方法get_range()还留在Battery类中，但向它传递一个参数，如car_在这种情况下，方法get_range()依然根据电瓶容量和汽车型号报告续航里程。
这让我们进入了程序员的另一个境界：解决上述问题时，我们从较高的逻辑层面(而不是语法层面)考虑；我们考虑的不是Python，而是如何使用代码来表示实物。到达这种境界后，我们经常会发现，现实世界的建模方法没有对错之分。有些方法的效率更高，但要找出效率最高的表示法，需要经过一定的实践。只要代码像我们希望的那样运行，就说明我们做的很好！即便我们发现自己不得不多次尝试使用不同的方法来重写类，也不必气馁；要编写出高效、准确的代码，都得经过这样的过程。动手试一试
冰淇淋小店：冰淇淋小店是一种特殊的餐馆。编写一个名为IceCreamStand的类，让它继承你为完成练习9-1或练习9-4而编写的Restaurant类。添加一个名为flavors的属性，用于存储一个有各种口味的冰淇淋组成的列表。编写一个显示这些冰淇淋的方法。创建一个IceCreamStand实例。并调用这个方法。
class Restaurant():
"""模拟餐馆的尝试"""
def __init__(self,name,business_hours,type_style):
'''初始化变量属性'''
self.business_hours = business_hours
self.type_style = type_style
def describe_restaurant(self):
'''对餐馆进行简单描述'''
print("This restaurant's name is " + self.name + ".")
print("Business Hours: " + self.business_hours + "\n")class IceCreamStand(Restaurant):
"""创建一个描述冰淇淋餐馆的类，调用餐馆的属性"""
def __init__(self,name,business_hours,type_style):
'''关联父类与子类'''
super().__init__(name,business_hours,type_style)
flavors = ['vanilla','coffee','blueberry','chocolates','green tea']
self.flavors = flavors
def describe_icecream(self):
'''打印冰淇淋的口味'''
print("The icecream tastes: ")
for flavor in self.flavors:
print(" --" + flavor)kentucky = IceCreamStand('ken','9:00--21:00','icecream')kentucky.describe_restaurant()kentucky.describe_icecream()运行结果如下：This restaurant's name is ken.Business Hours: 9:00--21:00The icecream tastes: &--vanilla&--coffee&--blueberry&--chocolates&--green tea分析：其实最难得是对现实世界的描述，随着学习的深入，对代码的掌握越来越熟练，可能对现实世界的描述是最难的，这时候要求我们去思考现实世界的物体，把这些东西用代码编写出来，感觉思考这些的时候好难，所以要锻炼自己描述现实世界的能力。9.4
随着我们不断地给类添加功能，文件可能变得很长，即便我们妥善地使用了继承亦如此。为遵循Python的总体理念，应让文件尽可能整洁。为在这方面提供帮助，Python允许我们将类存储在模块中，然后在主程序中导入所需的模块。9.4.1
导入单个类
下面来创建一个值包含Car类的模块。这让我们面临一个微妙的命名问题：在本章中，已经有一个名为car.py的文件，但这个模块也应命名为car.py，因为它包含表示汽车的代码。我们将这样解决这个命名问题：将Car类存储在一个名为car.py的模块中，该模块将覆盖前面使用的文件car.py。从现在开始，使用该模块的程序都必须使用具体的文件名，如my_car.py.下面是模块car.py,其中只包含Car类的代码：car.py（1）"""一个可用于表示汽车的类"""class Car():
'''一次模拟汽车的简单尝试'''
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")
def increment_odometer(self,miles):
"""将里程表读数增加指定的量"""self.odometer_reading += miles
在(1)处，我们包含了一个模块级文档字符串，对该模块的内容做了简要的描述。我们应为自己编写的每个模块都编写文档字符串。
下面来创建另一个文件my_car.py，在其中导入Car类并创建其实例：from car import Car
——（1）my_new_car = Car('audi','a8',2016)print(my_new_car.get_descriptive_name())my_new_car.update_odometer(25)#my_new_car.odometer_reading = 23my_new_car.read_odometer()
（1）处的import语句让Python打开模块car，并导入其中的Car类。这样我们就可以使用Car类了，就像它是这个文件中定义的一样。输出与我们前面看到的一样：
2016 Audi A8　　You can't roll back on odometer!　　This car has 40 miles on it.9.4.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 = 40
def get_descriptive_name(self):
'''返回整洁的描述性信息'''
long_name = str(self.year) + ' ' + self.make + " " + self.model
return long_name.title()
def update_odometer(self,mileage):
#将里程表读数设置为指定的值
#禁止将里程表读数往回调
if mileage &= self.odometer_reading:
self.odometer_reading = mileage
print("You can't roll back on odometer!")
def read_odometer(self):
'''打印一条指出汽车里程的消息'''
print("This car has " + str(self.odometer_reading) + " miles on it.")
def increment_odometer(self,mileage):
"""将里程表读数增加指定的量"""
self.odometer_reading += mileageclass Battery():
'''一次模拟电动汽车电瓶的简单尝试'''
def __init__(self,battery_size=70):
'''初始化电瓶的属性'''
self.battery_size = battery_size
def describe_battery(self):
'''打印一条描述电瓶容量的消息'''
print("This car has a " + self.battery_size + '-kwh battery.')
def get_range(self):
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 275
message = "This car can go approximately " + str(range)
message += ' miles on a full charge.'
print(message)class ElectricCar(Car):
'''模拟电动汽车的独特之处'''
def __init__(self,make,model,year):
'''初始化父类属性，再初始化电动汽车特有的属性'''
super().__init__(make,model,year)
self.battery = Battery()
现在，可以新建一个名为my_electric_car.py的文件，导入ElectricCar类，并创建一辆电动汽车了：
from car import ElectricCar'''从文件car.py导入类ElectricCar'''my_tesla = ElectricCar('tesla','model s',2016)print(my_tesla.get_descriptive_name())my_tesla.battery.describe_battery()my_tesla.battery.battery_size = 85my_tesla.battery.get_range()关联信息，将一个类与一个属性关联起来，通过这个属性来调用这个类中的方法，每次调用要告诉Python是通过什么方式调用，引荐人是谁。输出与我们前面看到的相同，但大部分逻辑都隐藏在一个模块中：2016 Tesla Model SThis car has a 70-kwh battery.This car can go approximately 275 miles on a full charge.9.4.3
从一个模块中导入多个类
可根据需要在程序文件中导入任意数量的类。如果我们要在同一个程序中创建普通汽车和电动汽车，就需要将Car类和ElectricCar类都导入：my_cars.pyfrom car import Car,ElectricCar
--（1）'''从文件car.py中导入类Car和ElectricCar类'''my_beetle = Car('volkswagen','beetle',2016)
__(2)print(my_beetle.get_descriptive_name())my_tesla = ElectricCar('tesla','model s',2016)
__(3)print(my_tesla.get_descriptive_name())
在(1)处从一个模块中导入多个类时，用逗号分隔了各个类。导入必要的类后，就可以根据需要创建每个类的任意数量的实例。
在这个实例中，我们在(2)处创建了一辆大众甲壳虫普通汽车，并在(3)处创建了一辆特斯拉Roadster电动汽车：　　2016 Volkswagen Beetle　　2016 Tesla Model S9.4.4
导入整个模块
你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。my_cars.py
import car
--(1)'''从文件car.py中导入类Car和ElectricCar类'''my_beetle = car.Car('volkswagen','beetle',2016)
--(2)print(my_beetle.get_descriptive_name())my_tesla = car.ElectricCar('tesla','model s',2016)
--(3)print(my_tesla.get_descriptive_name())
在(1)处，我们导入了整个car模块。接下来，我们使用语法module_name.class_name访问需要的类。像前面一样，我们在(2)处创建了一辆大众甲壳虫汽车，并在(3)处创建了一辆特斯拉Roadstere汽车。
即首先把整个模块都导进来，然后指明要使用这个模块中的哪一个类，主要是为了避免与这个文件中的类重名，这样就会出错，指明调用那个文件中的类，能够避免错误。也让Python有径可查。9.4.5
导入模块中的所有类
要导入模块中的每个类，可使用下面的语法：
from module_name import *
不推荐使用这种导入方式，其原因有二。首先，如果只要看一下文件开头的import语句，就能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出我们使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果我们一不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐这种方式，但我们可能会在别人编写的代码中见到它。
需要从一个模块中导入很多类时，最好导入整个模块，并使用module_name.class_name语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但我们清楚地知道在程序的哪些地方使用了导入的模块；我们还避免了导入模块中的每个类可能引发的名称冲突。9.4.6
在一个模块中导入另一个模块
有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。将类存储在多个模块中时，我们可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。
例如，下面将Car类存储在一个模块中，将ElectricCar和Battery类存储在另一个模块中。我们将第二个模块命名为Electric_car.py(这将覆盖前面创建的文件electric_car.py),并将Battery和ElectricCar类复制到这个模块中：electric_car.py
'''一组可用于表示电动汽车的类''from car import Car
--(1)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 = 275
message = "This car can go approximately " + str(range)
message += ' miles on a full charge.'
print(message)class ElectricCar(Car):
'''模拟电动汽车的独特之处'''
def __init__(self,make,model,year):
'''初始化父类属性，再初始化电动汽车特有的属性'''
super().__init__(make,model,year)
self.battery = Battery()
ElectricCar类需要访问其父类Car，因此在(1)处，我们直接将Car类导入该模块中。如果我们忘记了这行代码，Python将在我们试图创建ElectricCar实例时引发错误。我们还需要更新模块car，使其包含car类：
现在我们可以分别从每个模块中导入类，以根据需要创建任何类型的汽车了:
from car import Car
--(1)from electric_car1 import ElectricCarmy_beetle = Car('volkswagen','beetle',2016)print(my_beetle.get_descriptive_name())my_tesla = ElectricCar('tesla','model s',2016)print(my_tesla.get_descriptive_name())
在(1)处，我们从模块中导入了Car类，并从模块electric_car1中导入ElectricCar类。接下来，我们创建了一辆普通汽车和一辆电动汽车。这两种汽车都得以正确地创建：2016 Volkswagen Beetle2016 Tesla Model S9.4.7
自定义工作流程
正如我们看到的，在组织大型项目代码方面，Python提供了很多选项。熟悉所有这些选项很重要，这样我们才能确定那种项目组织方式是最佳的，并能理解别人开发的项目。
一开始应让代码结构尽可能简单。先尽可能在一个文件中完成所有工作，确定一切都能正确运行后，再将类移到独立的模块中。如果你喜欢模块和文件的交互方式，可在项目开始时就尝试将类存储到模块中。先找出让你能够编写处可行代码的方式，在尝试让代码更为组织有序。9.5
Python标准库
Python标准库是一组模块，安装Python都包含它。我们现在对类的工作原理已有大致的了解，可以开始使用其他程序员编写好的模块了。可使用标准库中的任何函数和类，为此只需在程序开头包含一条简单的import语句。下面来看模块collections中的一个类——OrderedDict。
字典让我们能够将信息关联起来，但它们不记录我们添加键-值对的顺序。要创建字典并记录其中的键-值对的添加顺序，可使用模块collections中的OrderedDict类。OrderedDict实例的行为几乎与字典相同，区别只在于记录了键-值对的添加顺序。
我们再来看一看第6章的favorite_languages.py示例，但这次将记录被调查者参与调查的顺序：
favorite_language.pyfrom collections
import OrderedDict
--(1)favorite_language = OrderedDict()
--(2)favorite_language['jen'] = "python"
--(3)favorite_language['sarah'] = 'C'favorite_language['edward'] = 'ruby'favorite_language['phil'] = 'python'for name,language in favorite_language.items():
print(name.title() + "'s favorite language is " + language.title() + ".")print(favorite_language)
我们首先从模块collections中导入OrderedDict类(见(1)).在(2)处，我们创建了OrderedDict类的一个实例，并将其存储到favorite_language中。请注意，这里没有使用花括号，而是调用OrderedDict()来创建一个空的有序字典，并将其存储在favorite_languages中。接下来，我们以每次一对的方式添加名字-语言对(见(3)处）。在(4)处，我们遍历favorite_languages,但知道将以添加的顺序获取调查结果：Jen's favorite language is Python.Sarah's favorite language is C.Edward's favorite language is Ruby.Phil's favorite language is Python.OrderedDict([('jen', 'python'), ('sarah', 'C'), ('edward', 'ruby'), ('phil', 'python')])
这是一个很不错的类，它兼具列表和字典的主要有点(在将信息关联起来的同时保留原来的顺序）。等我们开始对关系的现实情形建模时，可能会发现有序字典正好能够满足需求。随着我们对标准库的了解越来越深入，将熟悉大量可帮助我们处理常见情形的模块。动手试一试
骰子：模块random包含以各种方式生成随机数的函数，其中的randint()返回一个位于指定范围内的整数，例如，下面的代码返回一个1~6内的整数：
请创建一个Die类，它包含一个名为sides的属性，该属性的默认值为6。编写一个名为roll_die()的方法，它打印位于1和骰子面数之间的随机数。创建一个6面的骰子，再掷10次。
创建一个10面的骰子和一个20面的骰子，并将它们都掷10次。from random import randint'''从随机模块中导入随机整数类'''class Die():
'''模拟随机掷骰子'''
def __init__(self,sides):
'''初始化骰子基本属性'''
self.sides = sides
def roll_die(self,throw_times):
random_numbers = []
for i in range(throw_times):
x = randint(1,self.sides)
random_numbers.append(x)
print(random_numbers)
print("\n")nums = Die(6)nums.roll_die(6)nums_1 = Die(10)nums_1.roll_die(10)nums_2 = Die(20)nums_2.roll_die(10)运行结果如下：312351[3, 1, 2, 3, 5, 1]3921433238[3, 9, 2, 1, 4, 3, 3, 2, 3, 8]107141213116191820[10, 7, 14, 12, 13, 1, 16, 19, 18, 20]9.6
类编码风格
你必须熟悉有些与类相关的编码风格问题，在你编写的程序较复杂时尤其如此。
类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写风格，并在单词之间加上下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来来分隔方法；而在模块中，可使用两个空行来分隔类。
需要同时导入标准库的模块和我们编写的模块时，先编写导入标准库模块的import语句的程序中，再添加一个空行，然后编写导入我们自己编写的模块的import语句。在包含多条import语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。9.7
在本章中，我们学习了：如何编写类；如何使用属性在类中存储信息，以及如何编写方法，以让类具备所需的行为；如何编写方法__init__(),以便根据类创建包含所需属性的实例。我们见识了如何修改实例的属性——包括直接修改以及通过方法进行修改。我们还了解了：使用继承可简化相关类的创建工作；将一个类的实例用作另一个类的属性可让类更简洁。
我们了解到，通过将类存储在模块中，并在需要使用这些类的文件中导入它们，可让项目组织有序。我们学习了标准库，并见识了使用模块collections中的OrderedDict类的示例。最后，我们学习了编写类时应遵循的Python约定。
在第10章中，我们将学习如何使用文件，这让我们能够保存我们在程序中所做的工作，以及我们让用户做的工作。我们还将学习异常，这是一种特殊的Python类，用于帮助我们在发生错误时采取相应的措施。
暂无相关文章
相关搜索：
相关阅读：
相关频道：
&&&&&&&&&&&&&&&&
Python教程最近更新