Python基础学习（23）继承 类部分属性的补充 方法和函数 利用 pickle 存储对象
一、今日大纲
- 继承
- 类部分属性的补充
- 方法和函数
- 利用 pickle 存储对象
二、继承的基本实现
面向对象有三大特性：继承、封装、多态；今天我们主要介绍继承；假如我们要定义一个猫类和一个狗类，他们各自具有下面的绑定方法：
-
猫：吃、喝、睡、爬树
-
狗：吃、喝、睡、看家
class Cat:
def __init__(self, name):
self.name = name
def eat(self):
print(f'{self.name} is eating.')
def drink(self):
print(f'{self.name} is drinking.')
def sleep(self):
print(f'{self.name} is sleeping.')
def climb_tree(self):
print(f'{self.name} is climbing the tree.')
class Dog:
def __init__(self, name):
self.name = name
def eat(self):
print(f'{self.name} is eating.')
def drink(self):
print(f'{self.name} is drinking.')
def sleep(self):
print(f'{self.name} is sleeping.')
def guard_house(self):
print(f'{self.name} is guarding the house.')
xiaobai = Cat('xiaobai')
xiaobai.eat()
xiaobai.drink()
xiaobai.climb_tree()
xiaohei = Dog('xiaohei')
xiaohei.eat()
xiaohei.drink()
xiaohei.guard_house()
根据上面的代码我们可以看到，由于猫狗两个类由于大部分绑定方法比较相似，所以存在大量的重复代码，所以我们引入一个概念：继承；它主要用于解决代码的重复问题，下面是继承的基本实现方式：
class A:
pass
class B(A):
pass
# B继承A，A是父类，B是子类
# A是父类 基类 超类
# B是子类 派生类
而根据继承的思想，我们可以新定义一个父类：Pet，让Cat和Dog都继承此类，从而达到解决代码重复问题的作用：
class Pet:
def __init__(self, name):
self.name = name
def eat(self):
print(f'{self.name} is eating.')
def drink(self):
print(f'{self.name} is drinking.')
def sleep(self):
print(f'{self.name} is sleeping.')
class Dog(Pet):
def guard_house(self):
print(f'{self.name} is guarding the house.')
class Cat(Pet):
def climb_tree(self):
print(f'{self.name} is climbing the tree.')
xiaobai = Cat('xiaobai')
xiaobai.eat()
xiaohei = Dog('xiaohei')
xiaohei.eat()
对象寻找方法的基本逻辑：在定义对象时，先开辟空间，空间里存放一个类指针指向类；当调用某些方法时，对象会首先在自己的命名空间中寻找，如果没找到会借助类指针去类的命名空间中寻找，如果还未找到，则会借助类指针去父类中进行寻找。
如果我们这时想给猫和狗类定义一个新的方法：吃猫粮/狗粮
class Pet:
def __init__(self, name):
self.name = name
def eat(self):
print(f'{self.name} is eating.')
def drink(self):
print(f'{self.name} is drinking.')
def sleep(self):
print(f'{self.name} is sleeping.')
class Dog(Pet):
def guard_house(self):
print(f'{self.name} is guarding the house.')
def eat(self):
print(f'{self.name}吃狗粮。')
class Cat(Pet):
def climb_tree(self):
print(f'{self.name} is climbing the tree.')
def eat(self):
print(f'{self.name}吃猫粮。')
# 这时在重新调用小白和小黑的吃方法
xiaobai = Cat('xiaobai')
xiaobai.eat() # xiaobai吃猫粮。
xiaohei = Dog('xiaohei')
xiaohei.eat() # xiaohei吃狗粮。
这时我们发现，代码又出现了重复，我们是否可以利用传参实现把吃猫粮和吃狗粮合并称为一个方法呢？我们新定义两个属性来更直观地观察实现方法：智力值、血量；猫吃了猫粮智力值会增加，狗吃了狗粮生命值会增加。
class Pet:
def __init__(self, name, food):
self.name = name
self.food = food
self.blood = 100
self.wise = 100
def eat(self):
print(f'{self.name} is eating {self.food}.')
def drink(self):
print(f'{self.name} is drinking.')
def sleep(self):
print(f'{self.name} is sleeping.')
class Dog(Pet):
def eat(self):
self.blood += 100
Pet.eat(self) # 手动调用父类的方法，由于父类方法没有实例化，必须吧self传入
def guard_house(self):
print(f'{self.name} is guarding the house.')
class Cat(Pet):
def eat(self):
self.wise += 100
Pet.eat(self) # # 手动调用父类的方法，由于父类方法没有实例化，必须吧self传入
def climb_tree(self):
print(f'{self.name} is climbing the tree.')
xiaobai = Cat('xiaobai', '猫粮')
xiaobai.eat() # xiaobai吃猫粮。
xiaohei = Dog('xiaohei', '狗粮')
xiaohei.eat() # xiaohei吃狗粮。
print(xiaobai.wise, xiaohei.blood) # 200 200
在子类和父类方法存在重名的时候：子类对象调用方法会按照子类 -> 父类的顺序检查，先检查到的优先调用。而如果想同时调用子类和父类就要在子类中手动调用父类的方法，即添加Classname.func(self)。
# 思考题1：
class Father:
def __init__(self):
self.func()
def func(self):
print('in father')
class Son(Father):
def func(self):
print('in son')
Father.func(self)
Son()
# in son
# in father
# 思考题2：想给猫和狗定制个性属性
# 猫有eye_color眼睛的颜色
# 狗有size大小
class Pet:
def __init__(self, name, food):
self.name = name
self.food = food
self.blood = 100
self.wise = 100
def eat(self):
print(f'{self.name} is eating {self.food}.')
def drink(self):
print(f'{self.name} is drinking.')
def sleep(self):
print(f'{self.name} is sleeping.')
class Dog(Pet):
def __init__(self, name, food, size):
Pet.__init__(self, name, food)
self.size = size
def eat(self):
self.blood += 100
Pet.eat(self) # 手动调用父类的方法，由于父类方法没有实例化，必须吧self传入
def guard_house(self):
print(f'{self.name} is guarding the house.')
class Cat(Pet):
def __init__(self, name, food, eye_color):
Pet.__init__(self, name, food) # 调用了父类的初始化，去完成一些通用属性的初始化
self.eye_color = eye_color # 派生属性
def eat(self):
self.blood += 100
Pet.eat(self)
def climb_tree(self):
print(f'{self.name} is climbing the tree.')
xiaobai = Cat('xiaobai', 'maoliang', 'blue')
xiaohei = Dog('xiaohei', 'gouliang', 'big')
print(xiaobai.__dict__)
print(xiaohei.__dict__)
# {'name': 'xiaobai', 'food': 'maoliang', 'blood': 100, 'wise': 100, 'eye_color': 'blue'}
# {'name': 'xiaohei', 'food': 'gouliang', 'blood': 100, 'wise': 100, 'size': 'big'}
继承主要分为单继承和多继承：单继承只继承一个类；而多继承可以继承多个类；多继承的调用逻辑如下：
# 单继承: 只继承一个类
# 调子类的：子类自己有的时候
# 调父类的：子类自己没有的时候
# 调子类和父类的：子类父类都有，在子类中调用父类的
class A:
def func(self): print('in A')
class B(A): pass
class C(B): pass
class D(C): pass
d = D()
d.func() # in A
# 多继承：继承多个类
# 按照继承顺序，先继承的先寻找，找到就停止
# 有一些语言不支持多继承 java
# python语言的特点：可以在面向对象中支持多继承
class A:
def func(self): print('in A.')
class B:
def func(self): print('in B.')
class C(A, B): pass
C().func() # 继承第一个传入的类
三、类部分属性的补充
-
object类所有在 Python3x 中的类，都是继承 object 类的。一般按照引用的逻辑来讲，我们定义一个类中未定义
__init__的对象，发现并不会报错，这就是因为对象的类中其实是继承了object类的，所以我们以后在定义类的时候最好还是把object写出来，虽然实际上可以省略，但是这是一个约定的写法，即：class A: pass # 等价于 class A(object): pass class B: pass class C(A, B): pass print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>) print(B.__bases__) # (<class 'object'>,) -
类属性的补充
# 类属性的补充 # class_name.__name__ # 类的名字 # class_name.__doc__ # 类的文档字符串 # class_name.__base__ # 类的第一个父类 # class_name.__bases__ # 类的所有父类构成的元组 # class_name.__dict__ # 类的字典属性 # class_name.__module__ # 类定义所在的模块 # object_name.__class__ # 实例对应的类 class A: pass class B: """ 这个类主要是用来卖萌 """ pass class C(A, B): pass print(A.__base__) # <class 'object'> print(B.__base__) # <class 'object'> print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>) print(C.__class__) # <class 'type'> print(C.__module__) # __main__ print(B.__doc__) # 这个类主要是用来卖萌
四、函数和方法
# 绑定方法和普通的函数
from types import FunctionType, MethodType
# FunctionType: 函数
# MethodType: 方法 是对一个对象进行的操作
class A:
def func(self):
print('in func')
print(A.func) # 函数 <function A.func at 0x0000019D33A1BD90>
a = A()
print(a.func) # 方法 <bound method A.func of <__main__.A object at 0x0000019D33A1F780>>
print(isinstance(a.func, MethodType)) # True
print(isinstance(a.func, FunctionType)) # False
print(isinstance(A.func, MethodType)) # False
print(isinstance(A.func, FunctionType)) # True
# isinstance 和 type
# isinstance和type大部分时间用法是比较类似的
# 但是isinstance可以鉴别对象的类的父类，而type是不可以的
a = 1
b = 'abc'
print(isinstance(a, int)) # True
print(isinstance(a, float)) # False
print(isinstance(b, str)) # True
print(type(a) is int) # True
print(type(b) is str) # True
class Cat:
pass
xiaobai = Cat()
print(type(xiaobai) is Cat) # True
print(isinstance(xiaobai, Cat)) # True
class Animal: pass
class Cat(Animal): pass
xiaobai = Cat()
print(type(xiaobai) is Cat) # True
print(type(xiaobai) is Animal) # False
print(isinstance(xiaobai, Cat)) # True
print(isinstance(xiaobai, Animal)) # True
五、利用 pickle 存储对象
class Course:
def __init__(self, name, period, price):
self.name = name
self.period = period
self.price = price
python = Course('python', '6 month', 21800)
linux = Course('python', '5 month', 19800)
go = Course('python', '4 month', 12800)
import pickle
with open('pickle_file', 'ab') as f:
pickle.dump(python, f)
pickle.dump(linux, f)
pickle.dump(go, f)
with open('pickle_file', 'rb') as f:
while True:
try:
ret = pickle.load(f)
print(ret.__dict__)
except EOFError:
break
# {'name': 'python', 'period': '6 month', 'price': 21800}
# {'name': 'python', 'period': '5 month', 'price': 19800}
# {'name': 'python', 'period': '4 month', 'price': 12800}
# 在游戏中保存对象
# json不可以连续load连续dump
# json不可以dump和load对象(模块中没有类的声明,读取过程中会出现报错)
# AttributeError: Can't get attribute 'Course' on <module '__main__' from 'D:/Python/Python_Project/day24/03 pickle用法.py'>