Python Learning-面向对象编程-类 二

 目前为止，继承可能让人费解，子类和父类拥有一样的属性和方法（行为），那这个子类还有什么意义？ 实际上，通过继承，可以大大的节省重新写代码的工作，并且，**子类是可以拥有个性化的属性与方法的**

定义子类的专属属性和方法

class Store():
    """模拟一个小商店"""

    def __init__(self, store_name, store_type, commodity_list):
        """初始化属性store_name和store_type"""
        self.store_name = store_name
        self.store_type = store_type
        self.commodity_list = commodity_list

    def open_store(self):
        """开始营业"""
        print(self.store_name, '开始营业')

    def close_sotre(self):
        """商店打烊"""
        print(self.store_name, '已经打烊')

    def sell(self, commodity, quantity):
        """进货"""
        if commodity not in self.commodity_list.keys():
            print('本商店没有'+commodity)
            return

        self.commodity_list[commodity] += quantity
        print('商品'+commodity+'进货了'+str(quantity)+'件')

    def stock(self, commodity, quantity):
        """售货"""
        if commodity not in self.commodity_list.keys():
            self.commodity_list[commodity] = quantity
            print('新增商品'+commodity+str(quantity)+'件')
            return

        if self.commodity_list[commodity] >= quantity:
            self.commodity_list[commodity] += quantity
            print('商品'+commodity+'出售了'+str(quantity)+'件')
        else:
            print('商品'+commodity+'数量不足，无法出售，请忙进货')


class FoodStore(Store):
    """食品小店"""

    def __init__(self, store_name, store_type, commodity_list):
        """初始化"""
        # 调用父类中的构造方法，通过下面的代码让子类包含父类中的属性与方法
        super().__init__(store_name, store_type, commodity_list)

        # 小红的食品小店安装了一个自动问候器，每当有顾客上门的时候就会发发问候
        self.greetings = 'Welcome. Nice to meet you!'

    def say_hello(self):
        """向顾客发出问候语"""
        print(self.greetings)

# 定义一个商品清单
food_list = {'apple':100, 'milk':210, 'pear':72}
# 实例化一个叫商店叫美丽商店
food_store = FoodStore('美丽商店', 'supermarket', food_list)

# 访问父类中的方法与属性
print(food_store.commodity_list)
# 出售5个苹果
food_store.sell('apple',5)

print('-'*10)

# 访问子类的方法与属性
print(food_store.greetings)
# 访问子类中的方法
food_store.say_hello()

输出：

{‘apple’: 100, ‘milk’: 210, ‘pear’: 72}
商品apple进货了5件
———-
Welcome. Nice to meet you!
Welcome. Nice to meet you!

self.greetings = 'Welcome. Nice to meet you!'是为子类定义的一个属性，这里没有通过传递的方式来初始化参数，而是给了一个默认值

def say_hello(self):该方法是子类中自定义的方法，用来打印问候语

变量与属性

class Store():
    """模拟一个小商店"""
    # --略--


class FoodStore(Store):
    """食品小店"""

   def __init__(self, store_name, store_type, commodity_list):
        """初始化"""
        # 调用父类中的构造方法，通过下面的代码让子类包含父类中的属性与方法
        super().__init__(store_name, store_type, commodity_list)

        # 小红的食品小店安装了一个自动问候器，每当有顾客上门的时候就会发发问候
        self.greetings = 'Welcome. Nice to meet you!'

    def say_hello(self):
        """向顾客发出问候语"""
        print(self.greetings)

# 定义一个商品清单
food_list = {'apple':100, 'milk':210, 'pear':72}
# 实例化一个叫商店叫美丽商店
food_store = FoodStore('美丽商店', 'supermarket', food_list)
# 访问子类的方法与属性
print(food_store.greetings)
# 访问子类中的方法
food_store.say_hello()

# 访问类中的变量
print(FoodStore.greetings)
# 修改类中的变量值
FoodStore.greetings = 'hello'
print(FoodStore.greetings)

输出：

Welcome. Nice to meet you!
Welcome. Nice to meet you!
Welcome. Nice to meet you!
hello

可以看出，如果要访问类中的变量，需要通过类名+.访问，而不是类的实例

而且可以在类的外部对变量值进行访问，同样，属性的值也可以在外部进行访问修改

如果子类定义一个方法与父类的方法名称一样，但是功能不一样，结果会怎么样呢？

重写父类方法

如果在子类中定义了与父类中一样的方法名，那Python会忽略父类中的该方法，转而采用子类的方法；也就是说，子类可以在该方法中重新定义方法的行为

例：

扫描二维码关注公众号，回复： 2942295 查看本文章

class Store():
    """模拟一个小商店"""
    # --略--

class FoodStore(Store):
    """食品小店"""
    # 问候语
    greetings = 'Welcome. Nice to meet you!'

    def __init__(self, store_name, store_type, commodity_list):
        """初始化"""
        # 调用父类中的构造方法，通过下面的代码让子类包含父类中的属性与方法
        super().__init__(store_name, store_type, commodity_list)

    def say_hello(self):
        """向顾客发出问候语"""
        print(FoodStore.greetings)

    def open_store(self, week_day):
        """开始营业"""

        # 如果是星期日，则不休息一天
        if week_day == 7:
            print("今天不营业！")
        else:
            print(self.store_name, '开始营业')


# 定义一个商品清单
food_list = {'apple':100, 'milk':210, 'pear':72}
# 实例化一个叫商店叫美丽商店
food_store = FoodStore('美丽商店', 'supermarket', food_list)
# 调用方法
food_store.open_store(7)

输出：

今天不营业！

def open_store(self, week_day):重写了父类的open_store()方法；这里，该方法接收一个表示星期几的参数，如果是星期日（7）则本天休息一天不营业

通过输出可以看出，在调用opne_store()方法的时候，Python调用的是子类中的方法

将类封装进模块中，使用的时候导入类

将下面代码保存到store.py文件中

class Store():
    """模拟一个小商店"""

    def __init__(self, store_name, store_type, commodity_list):
        """初始化属性store_name和store_type"""
        self.store_name = store_name
        self.store_type = store_type
        self.commodity_list = commodity_list

    def open_store(self):
        """开始营业"""
        print(self.store_name, '开始营业')

    def close_sotre(self):
        """商店打烊"""
        print(self.store_name, '已经打烊')

    def sell(self, commodity, quantity):
        """进货"""
        if commodity not in self.commodity_list.keys():
            print('本商店没有'+commodity)
            return

        self.commodity_list[commodity] += quantity
        print('商品'+commodity+'进货了'+str(quantity)+'件')

    def stock(self, commodity, quantity):
        """售货"""
        if commodity not in self.commodity_list.keys():
            self.commodity_list[commodity] = quantity
            print('新增商品'+commodity+str(quantity)+'件')
            return

        if self.commodity_list[commodity] >= quantity:
            self.commodity_list[commodity] += quantity
            print('商品'+commodity+'出售了'+str(quantity)+'件')
        else:
            print('商品'+commodity+'数量不足，无法出售，请忙进货')

然后将下面代码保存到my_store.py文件中，然后导入sotre模块中的Store类

# 导入sotre模块中的Store类
form store import Store

class FoodStore(Store):
    """食品小店"""
    # 问候语
    greetings = 'Welcome. Nice to meet you!'

    def __init__(self, store_name, store_type, commodity_list):
        """初始化"""
        # 调用父类中的构造方法，通过下面的代码让子类包含父类中的属性与方法
        super().__init__(store_name, store_type, commodity_list)

    def say_hello(self):
        """向顾客发出问候语"""
        print(FoodStore.greetings)

    def open_store(self, week_day):
        """开始营业"""

        # 如果是星期日，则不休息一天
        if week_day == 7:
            print("今天不营业！")
        else:
            print(self.store_name, '开始营业')

也可以将Store类与FoodStore类都保存到一个类中，然后在主程序中调用

将Store类与FoodStore类都保存到store.py文件中，然后在main.py文件中引用它们

sotre.py文件如下：

class Store():
    """模拟一个小商店"""

    def __init__(self, store_name, store_type, commodity_list):
        """初始化属性store_name和store_type"""
        self.store_name = store_name
        self.store_type = store_type
        self.commodity_list = commodity_list

    def open_store(self):
        """开始营业"""
        print(self.store_name, '开始营业')

    def close_sotre(self):
        """商店打烊"""
        print(self.store_name, '已经打烊')

    def sell(self, commodity, quantity):
        """进货"""
        if commodity not in self.commodity_list.keys():
            print('本商店没有'+commodity)
            return

        self.commodity_list[commodity] += quantity
        print('商品'+commodity+'进货了'+str(quantity)+'件')

    def stock(self, commodity, quantity):
        """售货"""
        if commodity not in self.commodity_list.keys():
            self.commodity_list[commodity] = quantity
            print('新增商品'+commodity+str(quantity)+'件')
            return

        if self.commodity_list[commodity] >= quantity:
            self.commodity_list[commodity] += quantity
            print('商品'+commodity+'出售了'+str(quantity)+'件')
        else:
            print('商品'+commodity+'数量不足，无法出售，请忙进货')


class FoodStore(Store):
    """食品小店"""
    # 问候语
    greetings = 'Welcome. Nice to meet you!'

    def __init__(self, store_name, store_type, commodity_list):
        """初始化"""
        # 调用父类中的构造方法，通过下面的代码让子类包含父类中的属性与方法
        super().__init__(store_name, store_type, commodity_list)

    def say_hello(self):
        """向顾客发出问候语"""
        print(FoodStore.greetings)

    def open_store(self, week_day):
        """开始营业"""

        # 如果是星期日，则不休息一天
        if week_day == 7:
            print("今天不营业！")
        else:
            print(self.store_name, '开始营业')

main.py文件如下：

# 导入一个模块下的两个类
from store import Store,FoodStore

# 定义一个商品清单
food_list = {'apple':100, 'milk':210, 'pear':72}
# 实例化一个Store对象
my_store = Store('我的商店', 'supermarket', food_list)
# 开始营业
my_store.open_store()

# 实例化一个叫商店叫美丽商店
food_store = FoodStore('美丽商店', 'supermarket', food_list)
# 开始营业
food_store.open_store(7)

也可以只导入模块名，通过.符号来访问类

# 导入一个模块下的两个类
improt store as s

# 定义一个商品清单
food_list = {'apple':100, 'milk':210, 'pear':72}
# 实例化一个Store对象
my_sotre = s.Store('我的商店', 'supermarket', food_list)
# 开始营业
my_store.open_store()

# 实例化一个叫商店叫美丽商店
food_store = s.FoodStore('美丽商店', 'supermarket', food_list)
# 开始营业
food_store.open_store(7)

输出：

我的商店 开始营业
今天不营业！

Python标准库

安装好的Python包含一组标准库，在导入标准库中的模块与函数时，与上面的原理是一样的

并且，多人协作的时候，也只可以通过上面的方式导入别人写好的模块

目录
上一章 Python Learning-面向对象编程-类 一