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__)
什么是派生属性
在原本在父类中没有的属性,在我的子类属性中出现了
