pickle 继承

1.什么是方法,什么是函数

 class Foo:
         def chi(self):
               print("我是吃")
 
          @staticmethod
          def static_method():
                   pass
 
          @classmethod
           def class_method(cls):
                   pass    
 
 f = Foo()
 print(f.chi)   # <bound method Foo.chi of <__main__.Foo object at 0x10f688550>>
 print(Foo.chi)  # <function Foo.chi at 0x10e24a488> 
print(Foo.static_method)  
# <function Foo.static_method at 0x10b5fe620> 
print(Foo.class_method)  
# bound method Foo.class_method of <class '__main__.Foo'>>
 print(f.static_method) # <function Foo.static_method at 0x10e1c0620>
  print(f.class_method)   #<bound method Foo.class_method of <class '__main__.Foo'>>
 
        仔细观察, 我们能得到以下结论: 
  　　　　　　　　　　1. 类⽅方法. 不论任何情况, 都是⽅方法. 
　　　　　　　　　　　 2. 静态⽅方法, 不论任何情况. 都是函数 
　　　　　　　　　　　3. 实例例⽅方法, 如果是实例例访问. 就是⽅方法. 如果是类名访问就是函数.
 
     

2,从程序的角度上也是可以判断的

  from types import MethodType, FunctionType
  print(isinstance(a.func,MethodType))  #MethodType 方法类型
  print(isinstance(A.func,MethodType))
  print(isinstance(a.func,FunctionType)) #FunctionType 函数类型
  print(isinstance(A.func,FunctionType))

3.pickle

 1　　# pickle 游戏人物的状态的保存(存档读档)
 2 import pickle
 3  pickle模块可以序列化python中的所有自定义类的对象
 4  class Course:　　　　　　　　　　　　　　　　　　#创建一个课程类
 5      def __init__(self,name,price,period):
 6          self.name = name　　　　　　　　　　 #课程的名字=名字
 7          self.price = price　　　　　　　　　 #课程的价格=价格
 8          self.period = period　　　　　　　　 #课程的周期=周期
 9  class Student:　　　　　　　　　　　　　　　　　#创建一个学生类
10      def __init__(self,name,price,period):
11          self.name = name　　　　　　　　　　　#名字=名字
12          self.price = price        　　　　　
13          self.period = period
14  python = Course('python',88888,'6 months') #实例化一个python
15  linux = Course('linux',88888,'6 months')   #实例化一个linux
　
　　 with open('courses','wb') as f:            #把python实例化以wb模式写入到courses文件中
          pickle.dump(python,f)
 
    with open('courses1', 'wb') as f:　　　　   #把linux实例化以wb模式写入到courses1文件中　　　
          pickle.dump(linux,f)
 
　　 with open('courses','rb') as f:　　　　　　　#以rb的模式读出python
         python = pickle.load(f)
 
    with open('courses1', 'rb') as f: 　　　　　　#以rb的模式读出linux
        linux = pickle.load(f)
    print(python.name) 　　　　　　　　　　　　　　　#输出python的名字
    print(linux.name)　　　　　　　　　　　　　　　　#输出linux的名字

22  # 如果load一个对象,那么这个对象所对应的类必须已经在内存中  
　  # 同一个类的对象 会存储在同一个文件中
    #如果我不希望这个对象的load受到类读入的影响,就把这个类也写入到文件里

4.继承

　　子类可以自动拥有父类中除了私有属性外的其他所有所有内容

5.继承就是解决类与类之间代码重复的问题

6.类的继承语法:

7,使用继承这个概念的过程:

  class Animal:
        def __init__(self,name,kind,):
            self.name = name
            self.kind = kind
 　　　　
   class Cat(Animal):
                pass
   class Dog(Animal):
               pass  
 
 小花 = Cat('小花','金吉拉','喵喵')
 print(小花)
 print(小花.name)
 print(小花.kind)
      # 先开辟一块空间,并且空间中已经有了一个类指针,指向Cat
      # 执行__init__方法,在Cat类的空间中没有init方法,找Animal类中的init
      # 将空间返回给小花变量

7,继承

     子类调用方法,如果子类自己有用自己的,用了自己的就不用父类的了
     如果子类自己没有才调用父类的
     如果子类有个性化的父类没有的方法,可以单独定义在子类中 - 派生方法
     只有子类能够使用父类中的方法,父类不可以使用子类中的方法

 # class Animal:           #创建一个动物类          [Animal 动物:a nei mo]
 #     def __init__(self,name,kind,language):
 #         self.name = name       #动物的名字=名字
 #         self.kind = kind　　　　 #动物的种类=种类　[kind 种类:kan n d ]
 #         self.language = language #动物的叫=叫    [language 叫:lan g wei z]
 #     def eat(self):　　　　　　　　 #定义一个吃的方法  [eat 吃: yi t ]
 #         print('%s is eating'%self.name)
 #     def drink(self):　　　　　　　　#定义一个喝的方法 [drink 喝: zhuai k ]
 #         print('%s is drinking'%self.name)
 #     def yell(self):　　　　　　　　#定义一个叫的方法   [yell 叫: yao ]
 #         print('%s say %s'%(self.name,self.language))
 # class Cat(Animal):　　　　　#定义一个猫类 继承动物类
 #     def climb(self):      # 派生方法    [climb 爬: k lai m]
 #         print('%s can climb'%self.name)
 # class Dog(Animal):       #定义一个狗类 继承动物类
 #     def lookafter_door(self): # 派生方法
 #         print('%s can look after door'%self.name)
 # 小花 = Cat('小花','金吉拉','喵喵')
 # 小黑 = Dog('小黑','土狗','旺旺')
 # 小花.climb()
 # 小黑.lookafter_door()

8,# 子类使用父类的方法
    # 子类中有,父类中没有 : 用子类的
    # 父类中有,子类中没有 : 用父类的
    # 子类\父类中都有    : 默认情况下用子类的不用父类的
                       # 既想用父类又想用子类 : 父类名.方法名(子类对象),super().方法名()
    # 子类\父类中都没有   : 报错

 # class Animal:
 #     def __init__(self,name,kind,language):
 #         self.name = name
 #         self.kind = kind
 #         self.language = language
 #     def eat(self):
 #         print('%s is eating'%self.name)
 #     def drink(self):
 #         print('%s is drinking'%self.name)
 #     def yell(self):
 #         print('%s say %s'%(self.name,self.language))
 #     def sleep(self):
 #         print('%s 在睡觉'%self.name)
 # class Cat(Animal):
 #     def climb(self):      # 派生方法
 #         print('%s can climb'%self.name)
 #     def sleep(self):
 #         # Animal.sleep(self)    # 父类名,主动传self
 #         # super(cat,self).sleep()
 #         # super().sleep()           # super(子类名,self).方法名() 简写 记住这个就行
 #         print('团着睡')
 # class Dog(Animal):        # 派生方法
 #     def lookafter_door(self):
 #         print('%s can look after door'%self.name)
 #
 # 小花 = Cat('小花','金吉拉','喵喵')
 # 小花.sleep()   # 既希望走父类的基础的sleep,又希望走自己的方法
 # 当某一个方法,父类和子类都拥有的时候,那么在子类的方法中,调用父类的同名方法2种
     # 1.父类名.方法名(self,...)  # Animal.sleep(self)
     # 2.super().sleep(...)      # super(self,Cat).sleep()

"""人狗大战用继承方法写出来"""
 1 class Animal:          #创建一个动物类 [Animal 动物:a nei mo]
     def __init__(self,name,hp,ad):  #构造一个方法
         self.name = name
         self.hp = hp
         self.ad = ad
 class Person(Animal):　　　　　　#创建一个人类 继承动物类
     def __init__(self,name,sex,hp,mp,ad):
         super().__init__(name,hp,ad)
         self.sex = sex   # 派生属性
         self.mp = mp     # 派生属性
 
     def attack(self,dog):
         print('%s攻击了%s'%(self.name,dog.name))
         dog.hp -= self.ad
 
 class Dog(Animal):
     def __init__(self,name,kind,hp,ad):
         super().__init__(name,hp,ad)
         self.kind = kind   # 派生属性 (在原本在父类中没有的属性,在我的子类属性中出现了)
 
     def bite(self,person):
         print('%s咬了%s'%(self.name,person.name))
         person.hp -= self.ad
 
 alex = Person('alex','不详',10,10,0.1)
 hei = Dog('小黑','中华田园犬',999,1.1)
   print(alex.hp)
   hei.bite(alex)
   print(alex.hp)
   print(hei.hp)
   alex.attack(hei)
   print(hei.hp)
 print(hei.__dict__)

什么是派生属性

　　 在原本在父类中没有的属性,在我的子类属性中出现了