Python调对象存储接口 python3对象

1.定义类，实例化对象：

class Nanny(object):    #class 定义一个类名Nanny，这个类继承了object
    def __init__(self,name,age):    #__init__初始化方法，在创建对象的时候自动调用，第一个参数是必须有的self指的是创建的对象，
        self.name = name
        self.age = age

    def cook(self):   #在类中的普通函数叫做方法；都有一个self参数；可以被创建的对象调用
        print("这是一个做饭的过程")

obj1 = Nanny("小红",22)   #创建一个obj1对象，传入参数；这个参数被传入__init__初始化方法中
print(obj1.name)
print(obj1.age)
obj1.cook()  #调用类中的方法

 2类中的方法（普通方法（实例化方法），类方法，静态方法）和 类属性

class Nanny(object):
    Nanny_name = "this is Nanny name"   #这是一个类属性，可以通过类型.调用
    def __init__(self,name,age):
        self.name = name
        self.age = age

    @classmethod #这是一个类方法；通过@classmethod 
    def cook1(cls):  #方法的参数是cls 代表的这个类
        print("我是一个类方法")

    @staticmethod   #这是一个静态方法，通过@staticmethod
    def cook2():  #方法里面可以没有参数
        print("我是一个静态方法：这是我的使用说明")

    def cook(self):
        print("这是一个做饭的过程")


obj1 = Nanny("小红",22)
print(obj1.name)
print(obj1.age)
#方法的调用，实例化的对象可以调用类中的所有方法
obj1.cook()
obj1.cook1()
obj1.cook2()   
#但是类名只能调用静态方法和类方法
Nanny.cook1()
Nanny.cook2()

 3继承

何为继承，继承既新建的类具有被继承类的属性和方法；继承的目的是为了减少不必要的代码，实现代码的重复利用。那如何实现继承呢看代码：

class Parsenclass1(object):  #定义一个类让这个类继承object（python3中默认继承object；python2中需要指定）
    Parsen_var = "this is parsen var"

    def __init__(self):
        print("111")

    def f1(self):
        print("这是Parsenclass1的f1")

    def f2(self):
        print("这是Parsenclass1的f2")
　　
　　 def f3(self): 
　　　　 print("这是Parsenclass1的f3")

def f4(self): 
　　　　 print("这是Parsenclass1的f4")

class son1(Parsenclass1): #定义一个son1类，让这个类继承 Parsenclass1；那么这个类型具有父类中的所有属性和方法（除去私有的，暂时不表，后面介绍） 
　　son1_var = "son1关键字" 
　　def __init__(self): 
　　　　print("这是son1") 

　　def f1(self): 
　　　　print("这是son2的f1") 

　　def f2(self): 
　　　　print("这是son1的f2") 
　　　　self.f1() 


class son2(Parsenclass1): #定义一个son2，和son1的父类一样 

　　son2_var = "这是son2关键字" 

　　def __init__(self): 
　　　　print("这是son2") 

　　def f1(self): 
　　　　print("这是son2的f1") 

　　def f2(self): 
　　　　print("这是son2的f2")
　　
　　def f3(self): 
　　　　 print("这是son2的f3")


class son_son(son1,son2):  #定义一个son_son类，继承son1和son2；这是个多继承
    son_son_var = "这是son_son的关键字"
    def __init__(self):
        print("这是son_son")

    def f1(self):
        print("这是son_son的f1")


obj1 = son_son()  #创建对象
obj1.f2()  # 调用f2（）函数
obj1.f3()
obj1.f4()

print(son_son.__bases__)

执行结果如下：

这是son_son  #__init__函数默认执行
这是son1的f2   #当执行f2方法时，现在创造该对象的类中寻找，如果找到了就执行，如果没有找到则会向父类中寻找；这个父类时son1和son2，先在son1中寻找；找到了执行f2（）；当执行f2（）函数的时候遇到了
                  self.f1()函数，那这个f1函数指向的又是谁呢；创建类的时候self代表的是实例化对象（obj1），所以先去创建这个对象的类（son_son）中寻找f1函数；
这是son_son的f1

这是son2的f3    #当调用f3的时候，son1中没有f3函数；那么这个时候是继续沿着son1的父类中寻找还是去son2中寻找呢；看结果这个是先到son2中寻找f3函数（新式类中寻找父类的方法是从左到右，广度优先）
这是Parsenclass1的f4  #调用f4的时候先去son_son类中找，没有找到再去son1和son2中依次寻找，也没有找到最后去了Parsenclass1中寻找
(<class '__main__.son1'>, <class '__main__.son2'>)   #类.__bases__ 显示该类的父类