Python第八课——类

将函数和数据封装起来，形成类，用类再来创建对象。比如我创建了小狗这一个类，然后创造了名为William，年龄6岁的小狗，这只狗就是对象。

一、创建和使用类

1、创建dog类

以下是Python的类代码的基本结构：

class ClassName:
    # 一些类的属性和方法
    def __init__(self, arg1, arg2, ...):
        # 初始化方法
    def method1(self, arg1, arg2, ...):
        # 方法1
    def method2(self, arg1, arg2, ...):
        # 方法2
    # 其他方法

其中：

• class 关键字表示定义一个类。
• ClassName 是类的名称，按照惯例，类名称的首字母应该大写。
• 类的属性和方法写在类的内部，使用缩进表示属于类的代码块。
• __init__ 方法是类的构造函数，用于初始化对象的属性。
• self 是表示对象本身的关键字，在方法中必须作为第一个参数。
• 类的方法可以接受任意数量的参数，包括其他对象或基本数据类型。
• 在类中定义的属性和方法可以通过对象访问，也可以通过类访问。

class Dog:
#class就表示类，Dog首字母大写表示类
#一次模拟小狗的尝试
    def __init__(self,name,age):
        """初始化属性name和age"""#“”“”“”这个注释还必须缩进4格子
        self.name=name
        self.age=age
    def sit(self):
        #  """模拟小狗收到命令时做下"""
        print(f"{self.name} is now sitting")
    def roll_over(self):
        """模拟小狗收到命名时打滚"""
        print(f"{self} rolled over")

__int__()有四个下划线。name和age为通过实例可以访问的变量称为属性。里面的函数称为方法。

2、根据类创建实例

class Dog:
#class就表示类，Dog首字母大写表示类
#一次模拟小狗的尝试
    def __init__(self,name,age):
        """初始化属性name和age"""#“”“”“”这个注释还必须缩进4格子
        self.name=name
        self.age=age
    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)#类创建的实例
print(f"my dog is called {my_dog.name}")#要访问属性，用点号
print(f"my dog is {my_dog.age} ")

小写字母表示类创建的实例

• 访问属性

要访问属性（类中第一个函数里的形参，除了self），用点号

my_dog.name

• 调用方法

class Dog:
#class就表示类，Dog首字母大写表示类
#一次模拟小狗的尝试
    def __init__(self,name,age):
        """初始化属性name和age"""#“”“”“”这个注释还必须缩进4格子
        self.name=name
        self.age=age
    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)
my_dog.sit()
my_dog.roll_over()

• 创建多个实例

my_dog=Dog('willie',6)
your_dog=Dog('cue',16)

二、使用类和实例

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

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

2、给属性指定默认值

给里程这个默认值，不用放在形参里面

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")
my_new_car=Car('audi','a4',25)
my_new_car.read_odometer_reading()

3、修改属性的值

三种方法分别为：直接修改属性的值、通过方法设置、通过方法传递值（增加特定的值）

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")
    def update_odometer_reading(self,mileage):
        """返回格式化描述的信息"""
        self.odometer_reading=mileage#通过方法设置
    def increment_odometer(self,miles):
        """让里程表的读数增加特定的增量"""
        self.odometer_reading+=miles
my_new_car=Car('audi','a4',25)
my_new_car.odometer_reading=90#直接修改
my_new_car.update_odometer_reading(99)#通过方法设置
my_new_car.increment_odometer(100)#通过方法让属性的值递增

三、继承

子类继承父类的所有属性和方法

1、子类的__init__()方法

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")

    def get_descriptive_name(self):
        """返回格式化描述的信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def update_odometer_reading(self,mileage):
        """返回格式化描述的信息"""
        self.odometer_reading=mileage#通过方法设置
    def increment_odometer(self,miles):
        """让里程表的读数增加特定的增量"""
        self.odometer_reading+=miles
class ElectricCar(Car):#继承父类就加入父类的名
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)#super()是一个特殊的函数，
        #让你可以调用父类的方法
my_car=ElectricCar('benchi','baoma','x90')
print(my_car.get_descriptive_name())

2、给子类定义属性和方法

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")

    def get_descriptive_name(self):
        """返回格式化描述的信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def update_odometer_reading(self,mileage):
        """返回格式化描述的信息"""
        self.odometer_reading=mileage#通过方法设置
    def increment_odometer(self,miles):
        """让里程表的读数增加特定的增量"""
        self.odometer_reading+=miles
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        self.battey_size=40#给子类定义属性和方法
    def describe_battery(self):#给子类定义属性和方法
        """打印一条描述电池容量的消息"""
        print(self.battey_size)
my_car=ElectricCar('benchi','baoma','x90')
print(my_car.get_descriptive_name())
my_car.describe_battery()#给子类定义属性和方法

3、重写父类中的方法

子类中与父类同名的方法，python就会忽略父类中的方法 只关注你在子类中定义的方法

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")

    def get_descriptive_name(self):
        """返回格式化描述的信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def update_odometer_reading(self,mileage):
        """返回格式化描述的信息"""
        self.odometer_reading=mileage#通过方法设置
    def increment_odometer(self,miles):
        """让里程表的读数增加特定的增量"""
        self.odometer_reading+=miles
    def fill_gas_tank(self):#这是与子类同名的方法，python就会忽略父类中的方法
        #只关注你在子类中定义的方法
        """电动车有汽油"""
        print("the car has a gas tank")
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        self.battey_size=40
    def describe_battery(self):
        """打印一条描述电池容量的消息"""
        print(self.battey_size)
    def fill_gas_tank(self):#这是与父类同名的方法，python就会忽略父类中的方法
        #只关注你在子类中定义的方法
        """电动车没有汽油"""
        print("the car has not a gas tank")
my_car=ElectricCar('benchi','baoma','x90')
my_car.fill_gas_tank()#只会显示子类的方法，舍弃父类同名的方法

4、将实例用作属性

将大型类拆分成多个协同工作的小类，这种方法称为组合。

比如电动车中有和很多包含电池的属性和方法，就单独提取出来，作为一个类

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")

    def get_descriptive_name(self):
        """返回格式化描述的信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def update_odometer_reading(self,mileage):
        """返回格式化描述的信息"""
        self.odometer_reading=mileage#通过方法设置
    def increment_odometer(self,miles):
        """让里程表的读数增加特定的增量"""
        self.odometer_reading+=miles
    def fill_gas_tank(self):#这是与子类同名的方法，python就会忽略父类中的方法
        #只关注你在子类中定义的方法
        """电动车有汽油"""
        print("the car has a gas tank")
class Battery:#单独提出来
    """一次模拟电动车的简单尝试"""
    def __init__(self,battery_size=40):
        """初始化电池的属性"""
        self.battery_size=battery_size
    def describe_battery(self):
        """打印一条描述电池容量的信息"""
        print(f"{self.battery_size}_kwh")
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        self.battery=Battery()#单独提出的赋值给电动车
    def fill_gas_tank(self):#这是与父类同名的方法，python就会忽略父类中的方法
        #只关注你在子类中定义的方法
        """电动车没有汽油"""
        print("the car has not a gas tank")

my_car=ElectricCar('benchi','baoma','x90')
my_car.battery.describe_battery()#电动车类和电池类就在一起了

5、模拟实物

属性、方法、类、父类、子类、单独类之间的相互关系的运用，就可以用代码来描述实际事物。

四、导入类

将类存储在模块中，然后在主程序中导入所需的模块

1、导入单个类

将Car类存储在一个名为car.py的模块中，代码如下：

"""一个用来表示汽车的类"""#为自己创建的模块编写文档字符串
class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=110#给里程这个默认值，不用放在形参里面
    def read_odometer_reading(self):
        """返回格式化描述的信息"""
        print(f"{self.make} {self.model} has {self.odometer_reading} on it")

    def get_descriptive_name(self):
        """返回格式化描述的信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def update_odometer_reading(self,mileage):
        """返回格式化描述的信息"""
        self.odometer_reading=mileage#通过方法设置
    def increment_odometer(self,miles):
        """让里程表的读数增加特定的增量"""
        self.odometer_reading+=miles
    def fill_gas_tank(self):#这是与子类同名的方法，python就会忽略父类中的方法
        #只关注你在子类中定义的方法
        """电动车有汽油"""
        print("the car has a gas tank")

为自己创建的模块编写文档字符串

创建一个文件——my_car.py，在其中导入car类并创建实例。

from car import  Car#在my_car.py里导入Car类，创建实例
my_new_car=Car("audi",'a4','2024')
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading=23
my_new_car.read_odometer_reading()

2、在一个模块中存储多个类

from car import Car
class Battery:#单独提出来
    """一次模拟电动车的简单尝试"""
    def __init__(self,battery_size=40):
        """初始化电池的属性"""
        self.battery_size=battery_size
    def describe_battery(self):
        """打印一条描述电池容量的信息"""
        print(f"{self.battery_size}_kwh")
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        self.battery=Battery()#单独提出的赋值给电动车
    def fill_gas_tank(self):#这是与父类同名的方法，python就会忽略父类中的方法
        #只关注你在子类中定义的方法
        """电动车没有汽油"""
        print("the car has not a gas tank")

将这两个类放在一个模块electric_car.py中，然后Car这个类放在另一个模块car.py中，然后再my_car.py这个文件模块执行下面的代码

from car import  Car#在my_car.py里导入Car类，创建实例
from electric_car import ElectricCar

my_mustang=Car('ford','mustang',2024)
print(my_mustang.get_descriptive_name())

my_leaf=ElectricCar('nissan','leaf',2024)
print(my_leaf.get_descriptive_name())

3、使用别名

模块别名到类的别名，都是为了让名字更简单

from car import  Car#在my_car.py里导入Car类，创建实例
import electric_car as ec#别名
from electric_car import ElectricCar as EC#别名

my_mustang=Car('ford','mustang',2024)
print(my_mustang.get_descriptive_name())

my_leaf=EC('nissan','leaf',2024)
print(my_leaf.get_descriptive_name())

my_baby=ec.Battery(battery_size=50)
print(my_baby.battery_size)

4、找到合适的工作流程

先找到编写可行性代码的方式，再创建模块、重命名等操作，让代码简洁

五、Python标准库

python标准库就是一组模块，在安装python时已经包含在内。只需要在程序开头添加from ... import ...。例如模块random，这个模块中有一个函数randit()，它将两个整数作为参数，返回一个介于两者之间（含）的一个整数

#生成一个1-6之间的随机整数
from random import randit
randit(1,6)

在创建与安全有关的应用程序时，不要使用模块random()

 六、类的程序风格