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__)

 什么是派生属性

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