类

编写类时，定义的一大堆对象都有通用行为。

基于类创建的对象时，每个对象都自动具备这种通用行为，然后可以对这个对象赋予独特的个性

根据类创建对象，称为类的实例化

 

创建和使用类

创建一个类

class Dog:
    """ 一次模拟小狗的简单尝试 """
    def __init__(self, name, age):
        """ 初始化属性 name 和 dog """
        self.name = name  # 此处创建的变量有self前缀，可供类中的所有方法调用，可以通过类的任何实例访问
        self.age = age    # 这种可以通过实例访问的变量称为属性
    '''
    类中的函数称为方法，函数的一切有关做法都可以使用于方法，唯一的区别的是调用方式
    __init__() 是一个特殊的方法，创建实例时会自动运行，有点类似 C++ 的构造函数
    在这个方法的定义中self 必不可少，而且必须位于其他形参的前面，它是指向实例本身的作用，
    self 让实例能够访问类中的属性和方法
    '''
    def sit(self):
        """ 模拟小狗收到命令蹲下 """
        print(f"{self.name} is now sitting.")

    def roll_over(self):
        """ 模拟小狗收到命令打滚 """
        print(f"{self.name} rolled over.")

 

根据类来创建实例

my_dog = Dog("Willie", 6)  # 调用Dog类中的 __init__() 创建一个Dog的实例

""" 访问属性，句点表示法 """
print(f"My dog's name is {my_dog.name}.")

""" 调用方法， 句点表示法 """
my_dog.sit()

"""  创建多个实例  """
your_dog = Dog('Lucy', 5)
his_dog = Dog("Lucy", 5)
# 注意上面这两个是具有相同属性的不同实例

 

使用类和实例

给属性指定默认值

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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")


my_car = Car('audi', 'a4', 2020)
print(my_car.get_descriptive_name())
my_car.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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")


my_car = Car('audi', 'a4', 2020)
print(my_car.get_descriptive_name())
my_car.read_odometer()

my_car.odometer_reading = 100 #直接修改属性值
my_car.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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error")


my_car = Car('audi', 'a4', 2020)
print(my_car.get_descriptive_name())
my_car.read_odometer()

my_car.update_odometer(150)  # 使用方法修改属性的值
my_car.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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error")

    def increment_odometer(self, miles):    # 递增函数
        self.odometer_reading += miles


my_car = Car('audi', 'a4', 2020)
print(my_car.get_descriptive_name())
my_car.read_odometer()

# 通过方法对属性的值进行递增
my_car.increment_odometer(100)
my_car.read_odometer()

 

继承

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

子类的方法__init__()

在既有类的基础上编写新类时，通常需要调用父类的方法__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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error!")

    def increment_odometer(self, miles):  # 递增函数
        self.odometer_reading += miles


#   创建子类时，父类必须包含于当前文件中
class ElectricCar(Car):  # 在定义子类时，圆括号中必须指定父类的名称
    def __init__(self, make, model, year):  # 接受了创建Car实例的所需信息
        #   初始化父类的属性
        super().__init__(make, model, year)  # 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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error!")

    def increment_odometer(self, miles):  # 递增函数
        self.odometer_reading += miles


#   创建子类时，父类必须包含于当前文件中
class ElectricCar(Car):  # 在定义子类时，圆括号中必须指定父类的名称
    def __init__(self, make, model, year, battery):  # 接受了创建Car实例的所需信息
        #   初始化父类的属性
        super().__init__(make, model, year)   # super()是一个特殊的函数，可以调用父类的方法
        self.battery_size = battery  # 给子类定义的特有属性

    def describe_battery(self):     # 给子类定义的特有方法
        print(f"This car has a {self.battery_size}-kWh battery.")


my_tesla = ElectricCar('tesla', 'model s', 2019, 75)
my_tesla.describe_battery()

 

重写父类的方法

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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error!")

    def increment_odometer(self, miles):  # 递增函数
        self.odometer_reading += miles

    def fill_gas_tank(self):
        print("Please fill the tank.")


#   创建子类时，父类必须包含于当前文件中
class ElectricCar(Car):  # 在定义子类时，圆括号中必须指定父类的名称
    def __init__(self, make, model, year, battery):  # 接受了创建Car实例的所需信息
        #   初始化父类的属性
        super().__init__(make, model, year)  # super()是一个特殊的函数，可以调用父类的方法
        self.battery_size = battery  # 给子类定义的特有属性

    def describe_battery(self):  # 给子类定义的特有方法
        print(f"This car has a {self.battery_size}-kWh battery.")
    
    # 重新写父类的方法 fill_gas_tank()
    def fill_gas_tank(self):
        print("This car doesn't need a gas tank.")
        

my_tesla = ElectricCar('tesla', 'model s', 2019, 75)
my_tesla.describe_battery()

 

将实例用作属性

使用代码模拟实物时，所添加的细节会越来越多。

可以将大型类拆分成多个小类

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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error!")

    def increment_odometer(self, miles):  # 递增函数
        self.odometer_reading += miles

    def fill_gas_tank(self):
        print("Please fill the tank.")


class Battery:
    def __init__(self, battery_size=75):
        self.battery_size = battery_size

    def describe_battery(self):
        print(f"This car has a {self.battery_size}-kWh battery.")


class ElectricCar(Car):
    def __init__(self, make, model, year, battery):
        super().__init__(make, model, year)
        self.battery_size = Battery()
        # 这行让python创建一个Battery的实例并赋予属性self.battery_size

    def describe_battery(self):  # 给子类定义的特有方法
        print(f"This car has a {self.battery_size.battery_size}-kWh battery.")

    # 重新写父类的方法 fill_gas_tank()
    def fill_gas_tank(self):
        print("This car doesn't need a gas tank.")


my_tesla = ElectricCar('tesla', 'model s', 2019, 75)
my_tesla.describe_battery()

 

导入类

导入单个类

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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error!")

    def increment_odometer(self, miles):  # 递增函数
        self.odometer_reading += miles

    def fill_gas_tank(self):
        print("Please fill the tank.")

将上述代码存在当前文件夹的car文件（后缀.py）中, 然后在my_car文件中引用

from car import Car


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

 

 

在一个模块中存储多个类

将下列代码存在car文件中，这种就是在一个模块中存储多个类

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):
        return f"{self.make} {self.model} {self.year}".title()

    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        if mileage > self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("Error!")

    def increment_odometer(self, miles):  # 递增函数
        self.odometer_reading += miles

    def fill_gas_tank(self):
        print("Please fill the tank.")


class Battery:
    def __init__(self, battery_size=75):
        self.battery_size = battery_size

    def describe_battery(self):
        print(f"This car has a {self.battery_size}-kWh battery.")


class ElectricCar(Car):
    def __init__(self, make, model, year, battery):
        super().__init__(make, model, year)
        self.battery_size = Battery()
        # 这行让python创建一个Battery的实例并赋予属性self.battery_size

    def describe_battery(self):  # 给子类定义的特有方法
        print(f"This car has a {self.battery_size.battery_size}-kWh battery.")

    # 重新写父类的方法 fill_gas_tank()
    def fill_gas_tank(self):
        print("This car doesn't need a gas tank.")

 

从一个模块导入多个类

from car import Car, ElectricCar

# 导入多个类

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

my_tesla = ElectricCar("tesla", 'roadster', 2019, 75)
print(my_tesla.get_descriptive_name())

 

导入整个模块

import car

# 导入整个模块

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

my_tesla = car.ElectricCar("tesla", 'roadster', 2019, 75)
print(my_tesla.get_descriptive_name())

 

导入模块中的所有类

from car import *
# 导入模块中的所有类

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

my_tesla = ElectricCar("tesla", 'roadster', 2019, 75)
print(my_tesla.get_descriptive_name())

 

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

将Car类存储于car文件中，将electricCar和Battery存在另外一个文件electric_car中

然后就可以分别从每个模块中导入类中

from car import Car
from electirc_car import ElectricCar

# 导入多个类

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

my_tesla = ElectricCar("tesla", 'roadster', 2019, 75)
print(my_tesla.get_descriptive_name())

 

使用别名

使用别名会使代码简洁

from car import Car
from electirc_car import ElectricCar as EC

# 导入多个类

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

my_tesla = EC("tesla", 'roadster', 2019, 75)
print(my_tesla.get_descriptive_name())