第七章类

8.1 创建个使用类

8.1.1 创建一个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!")

1. 方法init() —— 类似于java中的有参构造方法，用于初始化属性值

方法init()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

方法init()定义成了包含三个形参：self、name和age。形参self必不可少，还必须位于其他形参的前面。

为何必须在方法定义中包含形参self呢？—类似于一个封装了所有传入的属性值的变量

因为Python调用这个init()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。self.name = name获取存储在形参name中的值，并将其存储到变量name中，然后该变量被关联到当前创建的实例.

通过实例访问的变量称为属性

8.1.2 根据类创建实例

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

让Python创建一条名字为'willie'、年龄为6的小狗。

Python使用实参'willie'和6调用Dog类中的方法init()。方法init()创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name和age。方法init()并未显式地包含return语句，但Python自动返回一个表示这条小狗的实例。我们将这个实例存储在变量my_dog中

命名约定:我们通常可以认为首字母大写的名称（如 Dog）指的是类，而小写的名称（如my_dog）指的是根据类创建的实例.

访问属性和方法-----句点表示法

my_dog.name 、my_dog.sit() 、my_dog.roll_over()；

创建多个实例---同java中一样，不同的引用占用不同的存储空间，他们之间是不相等的。

my_dog = Dog('willie', 6)

your_dog = Dog('lucy', 3)

注意：按需求根据一个类创建任意数量的实例，条件是将每个实例都存储在不同的变量中，或占用列表或字典的不同位置。

8.2 使用类和实例

需要执行的一个重要任务是修改实例的属性。

(1)可以直接修改实例的属性，(2)也可以编写方法以特定的方式进行修改。

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

8.2.2 给属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认

值时，在方法init()内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含

为它提供初始值的形参。(即：不需要在init方法的括号中再写上其形参变量)

example：下面来添加一个名为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 #新增的默认属性，未在init（）中添加。
    
    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()

8.2.3 修改属性的值

三种修改方法：直接通过实例进行修改；

通过方法进行设置；

通过方法进行递增（增加特定的值）

直接修改属性的值

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

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

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

对Car类所做的唯一修改是在第四行处添加了方法update_odometer()。这个方法接受一个里程值，并将其存储到self.odometer_reading中。在第11行处，我们调用了update_odometer()，并向它提供了实参23（该实参对应于方法定义中的形参mileage）。它将里程表读数设置为23；

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

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

8.3 继承

注意：一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

8.3.1 子类的方法init_()

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方

法init()需要父类施以援手。（super）

 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())      #父类中的方法

注意：创建子类时，父类必须包含在当前文件中，且位于子类前面。

8.3.2 python2.7中的继承

#函数super()需要两个实参：子类名和对象self。务必在定义父类时在括号内指定object。
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--

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

第14行，我们添加了新属性self.battery_size，并设置其初始值（如70）。

8.3.4 重写父类方法----子类应与要重写的父类方法同名

假设Car类有一个名为fill_gas_tank()的方法，它对全电动汽车来说毫无意义，因此你可能

想重写它.

def ElectricCar(Car): 
    --snip-- 
    def fill_gas_tank(): 
        """电动汽车没有油箱""" 
         print("This car doesn't need a gas tank!")

如果有人对电动汽车调用方法fill_gas_tank()，Python将忽略Car类中的方法

fill_gas_tank()，转而运行上述代码.

8.3.5 将实例用作属性

即：能需要将类的一部分作为一个独立的类提取出来。你可以将大型类拆分成多个协同工作的小类。

example：我们可能会发现其中包含很多专门针对汽车电瓶

的属性和方法。在这种情况下，我们可将这些属性和方法提取出来，放到另一个名为Battery的

类中，并将一个Battery实例用作ElectricCar类的一个属性。（封装了ElectricCar类中的部分属性）。

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()     #句点表示法层级调用

第25行代码：这行代码让Python在实例my_tesla中查找属性battery，并对存储在该属性中的Battery实例

调用方法describe_battery()。

8.4 导入类

为了让文件尽可能整洁，Python允许你将类存储在模块中，然后在主程序中导入所需的模块

8.4.1 导入单个类 --这里说的模块就是一个python文件

有两个文件分别是car.py和my_car.py

from car import Car         #淡入car.py 文件中的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()
#结果：
2016 Audi A4 
This car has 23 miles on it.

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

在car.py文件中存储了Car类和ElectricCar类

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

class Car(): 
    --snip-- 
class Battery(): 
    """一次模拟电动汽车电瓶的简单尝试""" 
    
    def __init__(self, battery_size=60): 
        """初始化电瓶的属性""" 
        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()

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

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

8.4.4 导入整个模块

注意：这里的模块虽然是一个文件，但文件中若有多个类，这个模块就

相当于java中的包了。

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

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

8.4.5 导入模块中的所有类--不推荐使用此种导入方式

from module_name import *

带来的问题：如果只要看一下文件开头的import语句，就

能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出你使用了模块中

的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其

他东西同名的类，将引发难以诊断的错误。

解决：需要从一个模块中导入很多类时，最好导入整个模块，并使用module_name.class_name语法

来访问类。

8.4.6 在一个模块中导入另一个模块（类似于java导包）

 from car import Car 
 from electric_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())

8.5 python标准库

Python标准库是一组模块。

example：模块collections中的一个类——OrderedDict（只在于记录了键—值对的添加顺序）

from collections import OrderedDict 

favorite_languages = OrderedDict() 

 favorite_languages['jen'] = 'python' 
favorite_languages['sarah'] = 'c' 
favorite_languages['edward'] = 'ruby' 
favorite_languages['phil'] = 'python'

 for name, language in favorite_languages.items(): 
    print(name.title() + "'s favorite language is " + 
        language.title() + ".")

我们创建了OrderedDict类的一个实例，并将其存储到favorite_languages中。请注意，这里没有使用花括号，而是调用OrderedDict()来创建一个空的有序字典，并将其存储在favorite_languages中

8.6 类编码风格

类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名

和模块名都采用小写格式，并在单词之间加上下划线。
1. 对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的
  
  功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，
  
  对其中的类可用于做什么进行描述。
  1. 使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
    
    两行分“类”，一行分方法
  4.需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import语句，再
  
  添加一个空行，然后编写导入你自己编写的模块的import语句。
  
  导库顺序：先标准库后自己

第七章 类