第九章类

最新推荐文章于 2022-12-07 00:14:43 发布

张小勇zhangxy

最新推荐文章于 2022-12-07 00:14:43 发布

阅读量357

点赞数

分类专栏： python编程从入门到实践（第二版）文章标签： python

本文链接：https://blog.csdn.net/lemogate/article/details/120867483

版权

python编程从入门到实践（第二版）专栏收录该内容

17 篇文章 24 订阅

订阅专栏

9.1 创建和使用类

梳理几个常见概念

面向对象：是把构成问题的事务分解成各个对象，建立对象的目的是为了描述某个事物在整个解决问题的步骤中的行为
面向过程：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现
类：具有共同特征的一类事物的抽象，类有三大特征：封装、继承、多态
对象：是客观世界中的某个具体事物，是类的实例化，对象包括属性和方法，万物皆对象
方法：类中的函数称为方法

9.1.1 创建 Dog 类

我们创建一个 Dog 类，狗有名字 name，有年龄 age，它还可以蹲下 sit，可以翻滚 roll_over

class Dog:  # 类名的首字母一般要大写
'''这是一个 Dog 类'''
    def __init__(self, name, age):  # name 和 age 是属性
        self.name = name  #self.name是变量, name是形参
        self.age = age

    def sit(self): #这个函数是一个方法
        print(f"{self.name.title()} is now sitting.")

    def roll_over(self):
        print(f"{self.name.title()} rolled over!")

当用类创建实例时，_ _ init _ _() 方法就自动运行，形参 self 是一个指向实例本身的引用，让实例能够访问类中的属性和方法,且 self 会自动传递，我们不需要额外处理它

9.1.2 使用 Dog 类

创建一个小狗的实例，访问属性

class Dog:
'''这是一个 Dog 类'''
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sit(self):
        print(f"{self.name.title()} is now sitting.")

    def roll_over(self):
        print(f"{self.name.title()} rolled over!")

my_dog = Dog('willie', 6)  # 用 Dog 类创建一个 my_dog 的实例
print(f"My dog's name is {my_dog.name.title()}.") # 使用类中的属性
print(f"My dog is {my_dog.age} years old.")
'''
输出：
My dog's name is Willie.
My dog is 6 years old.

'''

创建一个小狗的实例，调用方法

class Dog:
'''这是一个 Dog 类'''
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sit(self):
        print(f"{self.name.title()} is now sitting.")

    def roll_over(self):
        print(f"{self.name.title()} rolled over!")

my_dog = Dog('willie', 6)
my_dog.sit()
my_dog.roll_over()
'''
输出：
Willie is now sitting.
Willie rolled over!

'''

创建多个实例

class Dog:
'''这是一个 Dog 类'''
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sit(self):
        print(f"{self.name.title()} is now sitting.")

    def roll_over(self):
        print(f"{self.name.title()} rolled over!")

my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)

print(f"My dog's name is {my_dog.name.title()}.")
print(f"My dog is {my_dog.age} years old.")
my_dog.sit()

print()

print(f"Your dog's name is {your_dog.name.title()}.")
print(f"Your dog is {your_dog.age} years old.")
your_dog.sit()
'''
输出：
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 is now sitting.

'''

9.2 使用类和实例

类编写好后，根据类可以创建各种实例，这时有可能某些属性不是我们想要的，就需要修改实例属性
可以直接修改，也可以用特定的方式修改

9.2.1 Car 类

创建一个 Car 类，属性有制造商make、型号model、生产年 year
并创建一个方法，返回属性的完整信息

class Car:
'''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())

'''
输出：
Audi A4 2016

'''

9.2.2 给属性指定默认值

类中的属性必须有初始值，如果给某个属性指定了初始值，就不必给它提供形参了

class Car:
'''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {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()
'''
输出：
Audi A4 2016
This car has 0 miles on it

'''

9.2.3 修改属性的值

修改属性的值有三种方法：直接通过实例进行修改、通过方法进行设置、通过方法进行递增（增加特定的值）

直接修改属性的值

class Car:
'''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {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()
'''
输出：
Audi A4 2016
This car has 23 miles on it

'''

通过方法修改属性的值

class Car:
'''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        self.odometer_reading = 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()
'''
输出：
Audi A4 2016
This car has 23 miles on it

'''

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

class Car:
'''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

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

'''
输出：
Subaru Outback 2013
This car has 23500 miles on it
This car has 23600 miles on it

'''

9.3 继承

一个类可以继承另一个类，并自动获得另一个类的所有属性和方法，原来的类称为父类，新类称为子类，子类继承了父类的所有属性和方法，还可以定义属于自己的属性和方法

9.3.1 子类的方法 _ _ init _ _()

class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  # 初始化ElectricCar类属性
        super().__init__(make, model, year)  # 继承Car类属性

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

'''
输出：
Tesla Model S 2016

'''

9.3.2 python 2.7 中的继承

略

9.3.3 给子类定义属性和方法

给电池子类定义一个电池容量属性和打印电池容量值的方法

class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  # 初始化ElectricCar类属性
        super().__init__(make, model, year)  # 继承Car类属性
        self.battery_size = 70  # 添加电动车子类的新属性

    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-Kwh battery.")

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

'''
输出：
Tesla Model S 2016
This car has a 70-Kwh battery.

'''

9.3.4 重写父类的方法

如果父类方法不符合子类的行为，那么就可以对其重写，即定义一个与父类方法同名的方法，这样，程序在执行时，就不考虑父类方法，而只关注子类方法了

class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''烧油的汽车有油箱'''
        print("Oil car has a gas tank.")

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  
        super().__init__(make, model, year)  
        self.battery_size = 70  # 添加电动车子类的新属性

    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-Kwh battery.")

    def fill_gas_tank(self):
        '''电动车没有油箱'''
        print("This car doesn't need a gas tank.")

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.fill_gas_tank()

'''
输出：
Tesla Model S 2016
This car doesn't need a gas tank.

'''
''' 父类 Car 类中有一个 fill_gas_tank()方法，
子类 ElectricCar(Car) 也有一个fill_gas_tank() 方法，
由子类创建的实例调用的是子类重写的方法,而没有关注父类的方法
'''

9.3.5 将实例用作属性

当属性和方法清单越来越多时，我们可以把一部分作为独立的类提取出来
比如，例子中与电池相关的方法可以独立出来，创建一个新类 Battery，并将 Battery 类作为 ElectricCar 类的一个属性

class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''烧油的汽车有油箱'''
        print("Oil car has a gas tank.")
class Battery():   # 此处有括号，是否是因为是父类或则父类子类属性的缘故？
    '''这是提取的电池类'''
    def __init__(self, battery_size = 70):
        self.battery_size = battery_size

    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-Kwh battery.")

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  
        super().__init__(make, model, year)  
        self.battery = Battery()  # 电池新类关联到电动车的电池属性

    def fill_gas_tank(self):
        '''电动车没有油箱'''
        print("This car doesn't need a gas tank.")

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

'''
输出：
Tesla Model S 2016
This car has a 70-Kwh battery.

'''

再给 Battery 类添加一个方法，根据容量报告行驶里程数

class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''烧油的汽车有油箱'''
        print("Oil car has a gas tank.")
class Battery():   # 此处有括号，是否是因为是父类或则父类子类属性的缘故？
    '''这是提取的电池类'''
    def __init__(self, battery_size = 70):
        self.battery_size = battery_size

    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-Kwh battery.")

    def get_range(self):
        '''打印可行使里程数'''
        if self.battery_size == 70:
            drive_distence = 240
        elif self.battery_size == 100:
            drive_distence = 270
        print(f"This car can drive {drive_distence} km.")

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  
        super().__init__(make, model, year)  
        self.battery = Battery()  # 电池新类关联到电动车的电池属性

    def fill_gas_tank(self):
        '''电动车没有油箱'''
        print("This car doesn't need a gas tank.")

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
print()
my_tesla.battery.battery_size = 100  #直接修改电池容量
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

'''
输出：
Tesla Model S 2016
This car has a 70-Kwh battery.
This car can drive 240 km.

This car has a 100-Kwh battery.
This car can drive 270 km.

'''

9.3.5 模拟实物

解决问题，要从逻辑层面考虑，而不是语言本身

9.4 导入类

为了让文件尽可能整洁，类可以存放在模块中，使用时在主程序中导入
所需的模块car.py 包括上节创建的 Car 类，我们的主程序用my_car.py

9.4.1导入单个类

''' car.py 文件，存放Car 类'''
class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''烧油的汽车有油箱'''
        print("Oil car has a gas tank.")

''' 这是导入单个类的例子 '''
from car import Car

my_new_car = Car('audi', 'a4', '2019')
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23
my_new_car.read_odometer()
'''
输出:
Audi A4 2019
This car has 23 miles on it

'''

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

可以根据需要在一个模块中存储多个类

'''car.py中存储 Car，Battery，ElectricCar三个类'''
class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''烧油的汽车有油箱'''
        print("Oil car has a gas tank.")
class Battery:   # 此处有括号，是否是因为是父类或则父类子类属性的缘故？，也可以无括号？
    '''这是提取的电池类'''
    def __init__(self, battery_size = 70):
        self.battery_size = battery_size

    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-Kwh battery.")

    def get_range(self):
        '''打印可行使里程数'''
        if self.battery_size == 70:
            drive_distence = 240
        elif self.battery_size == 100:
            drive_distence = 270
        print(f"This car can drive {drive_distence} km.")

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  
        super().__init__(make, model, year)  
        self.battery = Battery()  # 电池新类关联到电动车的电池属性

    def fill_gas_tank(self):
        '''电动车没有油箱'''
        print("This car doesn't need a gas tank.")

在 my_electric_car.py 中使用 ElectricCar 类

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

'''
输出：
Tesla Model S 2016
This car has a 70-Kwh battery.
This car can drive 240 km.

'''

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

使用 9.4.2 中的 car.py 模块
在my_cars.py 中使用 Car 和 ElectricCar 类

from car import Car,ElectricCar

# 使用 Car 类
my_audi = Car('audi', 'a4', 2018)
print(my_audi.get_descriptive_name())

# 使用 ElectricCar 类
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())

'''
输出：
Audi A4 2018
Tesla Model S 2019

'''

9.4.4 导入整个模块

使用 9.4.2 中的 car.py 模块
在your_cars.py 中使用 Car 和 ElectricCar 类，使用 module_name.Class_Name 访问

import car

# 使用 Car 类
your_audi = car.Car('audi', 'a4', 2018)
print(your_audi.get_descriptive_name())

# 使用 ElectricCar 类
your_tesla = car.ElectricCar('tesla', 'model s', 2019)
print(your_tesla.get_descriptive_name())
'''
输出：
Audi A4 2018
Tesla Model S 2019

'''

9.4.5 导入模块中的所有类

语法如下：

from module_name import *

尽量不要这样做，因为：

如果分别导入，会清楚的知道程序使用了哪些类
一股脑导入，可能会引起命名的混乱

9.4.6 在一个模块中导入另一个模块

有时候一个模块中的类依赖于另一个模块中的类，这时，可在前一个模块中导入必要的类
比如： ElectricCar(Car) 就依赖于 Car 类，如果两个模块单独存放，此时可以在 ElectricCar(Car) 模块中先导入 Car 类，然后再使用

car.py

class Car:
    '''这是一个 Car 类'''
    def __init__(self, make, model, year):
        '''初始化汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 里程表读数初始值为 0

    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.make} {self.model} {self.year}"
        return long_name.title()

    def read_odometer(self):
        '''打印汽车的里程信息'''
        print(f"This car has {self.odometer_reading} miles on it")

    def update_odometer(self, mileage):
        '''将里程表读数设置成指定的值'''
        if self.odometer_reading > mileage:
            print("You can't roll back!!!")
        else:
            self.odometer_reading = mileage

    def increment_odometer(self,miles):
        '''将里程表增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''烧油的汽车有油箱'''
        print("Oil car has a gas tank.")

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(f"This car has a {self.battery_size}-Kwh battery.")

    def get_range(self):
        '''打印可行使里程数'''
        if self.battery_size == 70:
            drive_distence = 240
        elif self.battery_size == 100:
            drive_distence = 270
        print(f"This car can drive {drive_distence} km.")

class ElectricCar(Car):
    '''这是一个电动车子类，继承 Car 类'''
    def __init__(self, make, model, year):  
        super().__init__(make, model, year)  
        self.battery = Battery()  # 电池新类关联到电动车的电池属性

    def fill_gas_tank(self):
        '''电动车没有油箱'''
        print("This car doesn't need a gas tank.")

my_cars,py

from car import Car
from elctric_car import ElectricCar

# 使用 Car 类
my_audi = Car('audi', 'a4', 2018)
print(my_audi.get_descriptive_name())

# 使用 ElectricCar 类
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())

''''
输出：
Audi A4 2018
Tesla Model S 2019

'''

9.4.7 使用别名

可以给类指定别名，代码如下：

from elctric_car import ElectricCar as EC

my_tesla = EC('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())

'''
输出：
Tesla Model S 2019

'''

9.4.8 自定义工作流程

如何使代码简洁：我们可以首先在一个文件中完成所有工作，确定可以正常运行后，再将类移到单独的模块中

9.5 python 标准库

模块 random 中有两个函数 randint() 和 choice()

randint() 用两个整数作为参数，随机返回两个整数之间的一个数，包括这两个整数
choice() 可以从列表或元组中随机返回其中的一个元素

from random import randint,choice

print(randint(1,6))  # 输出1到6之间的随机数，包括1和6

a = ['a', 'b', 'c', 'd']
print(choice(a)) # 输出列表中的任一元素


输出：
5
d

'''

9.6 类编码风格

类名采用驼峰命名法，即类名中的每个单词首字母大写，但不使用下划线
实例名和模块名都是用小写，使用下划线
每个类后面要紧跟一个文档字符串，用来描述类的功能
在类中，一个空行分隔方法；在模块中，两个空行分隔类
导入模块时，先导入标准库模块，空一行，再导入自己编写的模块

9.7 小结

略

张小勇zhangxy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
第九章类

类9.1 创建和使用类9.1.1 创建 Dog 类9.1.2 使用 Dog 类9.2 使用类和实例9.2.1 Car 类9.2.2 给属性指定默认值9.2.3 修改属性的值9.3 继承9.1 创建和使用类梳理几个常见概念面向对象：是把构成问题的事务分解成各个对象，建立对象的目的是为了描述某个事物在整个解决问题的步骤中的行为面向过程：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现类：具有共同特征的一类事物的抽象，类有三大特征：封装、继承、多态对象：是客观世界中的某个具体事物，是
复制链接

扫一扫