[Python知识库]Python 3 《Class》入门练习

（一）创建和使用类

1、创建dog类

在Python中，首字母大写的名称指的是类。类中的函数称为方法；你前面学到的有关函数的一切都适用于方法，唯一重要的差别是调用方法的方式。方法__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

方法__init__()包含三个形参：self、name和age。self必不可少，还必须位于其他形参的前面，而且在实参传递时，self是自动传递的，以self为前缀的变量都可供类中的所有方法使用.

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

2、根据类创建实例

str(my_dog.age)将my_dog的属性age的值6转换为字符串，使用句点表示法来调用Dog类中定义的任何方法。

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.")
my_dog = Dog('willie', 6)

my_dog.sit()
my_dog.roll_over()

3、创建多个实例

?

#------创建多个实例----------
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("Your dog's name is " + your_dog.name.title() + '.')
print("Your dog is " + str(your_dog.age) + "years old")
your_dog.sit()

 

（二）使用类和实例

1、编写一个表示汽车的类，它存储了有关汽车的信息

class Car():
    """一次模拟车的简单尝试"""
    def __init__(self, make, model, year ):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year

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

2、给属性指定初始值

类中的每个属性都必须有初始值，可以在方法__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(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())
my_new_car.read_odometer()

3、修改属性的值

（1）直接修改属性的值

#方法一修改属性的值
class Car():
    my_new_car = Car('audi', 'a4', 2016)
    print(my_new_car.get_descriptive())
    my_new_car.odometer_reading = 23
    my_new_car.read_odometer()

（2）通过方法修改属性的值

#方法二修改属性的值
class Car():
    """一次模拟车的简单尝试"""
    #类中创建方法
    def __init__(self, make, model, year ):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive(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):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage

class Car():
    new_car = Car('audi', 'a4', 2016)
    print(new_car.get_descriptive())

    new_car.update_odometer(100)
    new_car.read_odometer()

（3）通过方法实现属性值的递增

class Car():
    """一次模拟车的简单尝试"""
    #类中创建方法
    def __init__(self, make, model, year ):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 10

    def get_descriptive(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 Car():
    new_car = Car('subura', 'outback', 2018)
    print(new_car.get_descriptive())

    new_car.update_odometer(5)
    new_car.read_odometer()

    new_car.increment_odometer(500)
    new_car.read_odometer()

（三）继承

此我们可以在前面创建的Car类的基础上创建新类ElectricCar，这样我们就只需为电动汽车特有的属性和行为编写代码。

1、子类的方法

父类必须包含在当前文件中，且位于子类前面。super()是一个特殊函数，帮助Python将父类和子类关联起来。Python调用ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。

#!/usr/bin/env python
# -*- coding:utf-8 -*- 
# author: Christal date: 2021/11/23

# 创建类
class Car():
    """一次模拟车的简单尝试"""
    #类中创建方法
    def __init__(self, make, model, year ):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 10

    def get_descriptive(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):
        """初始化父亲的属性"""
        supper().__init__(make, model, year)

my_tesla = ElectricCar('tesla', 'model', 2020)
print(my_tesla.get_descriptive())

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

#!/usr/bin/env python
# -*- coding:utf-8 -*- 
# author: Christal date: 2021/11/23

# 创建类
class Car():
    """一次模拟车的简单尝试"""
    #类中创建方法
    def __init__(self, make, model, year ):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 10

    def get_descriptive(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)
        self.battery_size = 70

    def describe_battery(self):
        """打印一条描述电瓶容量的信息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

my_tesla = ElectricCar('tesla', 'model', 2020)
print(my_tesla.get_descriptive())
my_tesla.describe_battery()

3、重写父类的方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个与父类方法同名的方法。这样，Python只关注子类中定义的相应方法。

4、将实例作为属性

类中添加的细节越来越多时，属性和方法清单以及文件会越来越长的，此时，需要将类的一部分作为一个独立的类提取出来，将大类拆分成多个协同工作的小类。

我们定义了一个名为Battery的新类，它没有继承任何类。方法__init__()除

self外，还有另一个形参battery_size，这个形参是可选的；在ElectricCar类中添加了名为self.battery 的属性，这行代码让Python创建了一个新的Battery实例，现在每个ElectricCar实例都包含一个自动创建的Battery实例。

#!/usr/bin/env python
# -*- coding:utf-8 -*- 
# author: Christal date: 2021/11/24

# 创建类
class Car():
    """一次模拟车的简单尝试"""
    #类中创建方法
    def __init__(self, make, model, year ):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 10

    def get_descriptive(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 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 EletricCar(Car):
    """电动汽车的独特之处"""

    def __init__(self, make, model, year):
        """初始化父类的属性，在初始化电动汽车独有的属性"""
        super().__init__(make, model, year)
        self.battery = Battery()  #独特属性初始化，用类表示

my_tesla = EletricCar('tesla', "model's", 2021)
print(my_tesla. get_descriptive())

my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

（四）导入类

随着你不断地给类添加功能，文件可能很长，即便你妥善地使用了继承亦如此。为遵循Python的总体理念，应让文件尽可能整洁。Python允许将类存储在模块中，然后在主程序中导入所需的模块。

1、导入单个类

将类Car单独保存为car.py，然后建立my_car.py文件，文件代码如下

from car import Car

my_new_car = Car('audio', 'a4', 2021)
print(my_new_car.get_descriptive())

my_new_car.odometer_reading = 70
my_new_car.read_odometer()

2、从一个模块中导入多个类

将类Car、ElectricCar和Battery全部写入class_electricar1，实现在一个模块中存储多个类，在my_car.py中可以实现多个类的导入，然后用户可以根据需要创建每个类的任意数量实例。

from class_electricar1 import Car， EletricCar

my_new_car = Car('audio', 'a4', 2021)
print(my_new_car.get_descriptive())

my_new_car.odometer_reading = 70
my_new_car.read_odometer()

my_tasla =  EletricCar('tesla', "model's", 2021)
print(my_tasla.get_descriptive())

my_tasla.odometer_reading =500
my_tasla.battery.describe_battery()
my_tasla.battery.get_range()

3、导入整个模块

需要后续使用句点表示需要访问你的类，

import class_electricar1 as car

my_car = car.Car('aodi', 'a4',2020)
print(my_car.get_descriptive())

my_tesla = car.EletricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive())

4、导入模块中的所有类

语句类型为：from module_name import *， 不推荐使用，在此不做过多介绍。同样也可以在一个模块中导入另外一个模块，导入的方法与上述方法一致。

（五）Python标准库

Python标准库是一个模块，可以使用import语句导入。字典让你能够将信息关联起来，但是不记录添加键—值对的顺序。要创建字典并记录键—值对的添加顺序，可使用模块collections中的OrderedDict类。

from collections import OrderedDict

fav_lans = OrderedDict()

fav_lans['jen'] = 'python'
fav_lans['sarah'] = 'c'
fav_lans['edward'] = 'C#'
fav_lans['phil'] = 'python'

for name, language in fav_lans.items():
    print(name.title() + "'s favoriate languages is " \
    + language.title() + ".")
print("The following languages have been mentioned:")

for language in set(fav_lans.values()):  # 遍历字典的所有的值
                                         # 有没有set()函数都可以提取字典中所有的value,
                                         # 加入set（）之后，保证不会重复
    print(language.title())

（六）类编码风格

类名称采用驼峰命名法，即类名中的每个单词的首字母大写，不适用下划线。实例名和模块名都采用小写格式，并在单词之间加上下滑线。

每个类后面都包含一个文档字符串，简单描述类的功能，每个模块也都包含一个文档字符串，用于对其中的类用于做什么进行描述。