类 面向对象 继承 学习笔记

class Foo:
    def __init__(self):
        self.age = 18
    def Bar(self):
        print(self.age)
    def Hello(self):
        print(self.age)
# 根据类Foo创建对象obj
obj = Foo()
obj.Bar()  # 执行Bar方法
obj.Hello()  # 执行Hello方法　

18
18

class Foo:
    def __init__(self,bk):
        self.age = bk
    def Bar(self):
        print(self.age)
    def Hello(self):
        print(self.age)
# 根据类Foo创建对象obj
obj1 = Foo(18)
obj1.Bar()  # 执行Bar方法
obj1.Hello()  # 执行Hello方法　

obj2 = Foo(454)
obj2.Bar()  # 执行Bar方法
obj2.Hello()  # 执行Hello方法　

18
18
454
454

 

在终端输出如下信息 小明，10岁，男，上山去砍柴 小明，10岁，男，开车去东北 小明，10岁，男，最爱大保健 class foo: def __init__(self,name,age,gender): self.name = name self.age = age self.gender = gender def kanchai(self): print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.gender)) def qudongbei(self): print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.gender)) def dabaojian(self): print('%s,%s岁,%s,最爱大保健'%(self.name,self.age,self.gender)) obj = foo('小明',18,'男') obj.kanchai() obj.qudongbei() obj.dabaojian()

 

继承
class A:
    def bar(self):
        print('bar')
        self.f1()
class B(A):
    def f1(self):
        print('B')

class C:
    def f1(self):
        print('C')

class D(C,B):
    pass
d1 = D()
d1.bar()
#输出：
bar
C

 

自动执行父类的构造方法
super 关键字  
class Annimal:
    def __init__(self):
        print('a构造方法')
        self.ty = '动物'
class cat(Annimal):
    def __init__(self):
        print('B构造方法')
        self.n = '猫'
        super(cat,self).__init__()
# a = Annimal()
c = cat()

 

通过反射寻找
1文件：class Foo:
    def __init__(self,name):
        temp = 'xxx'
        self.name = name
    def show(self):
        print('show')
执行文件：
m = __import__('1',fromlist=True)#导入模块
class_name = getattr(m,'Foo')#getattr找到模块中的类Foo
obj = class_name('alex')#创建类的对象 obj 并传入实参‘alex’
val = getattr(obj,'name')#geiattr找到形参name对应的实参

print(val)

 

通过类访问
# class Foo:
#     @staticmethod   #静态方法
#     def f1():
#         print('f1')
# Foo.f1()
# class Foo:
#     @classmethod  #类方法
#     def f1(cls):
#         print('f1')
# Foo.f1()
# class Foo:
#     name = 'slex'  #静态字段
# print(Foo.name)

 

class Foo:
    def __init__(self,name):
        self.name = name
    @property   #特性（属性） 将方法本应（）执行伪装成字段方式执行
    def end(self):
        tamp = '%s sb'% self.name
        return tamp
obj = Foo('alex')
ret = obj.end
print(ret)

class Foo:
    def __init__(self,name):
        self.name = name
    @property   #特性（属性） 将方法本应（）执行伪装成字段方式执行
    def end(self):
        tamp = '%s sb'% self.name
        return tamp
    @end.setter  #设置特性（）属性
    def end(self,v):
        print(v)
obj = Foo('alex')
ret = obj.end
print(ret)
obj.end = 123

class Foo:
    xo = 'xo'
    __xoo = 'xoo' #成员修饰符
    def f1(self):
        print(Foo.__xoo)
print(Foo.xo)  #输出xo
ret = Foo()
ret.f1()   #输入xoo

 

class Foo:
    def __init__(self):
        print(1)
    def __call__(self, *args, **kwargs):
        print(2)
    def __getitem__(self, item):
        print(item)
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)
dic = Foo()
dic['sasa']
dic['a'] = 'b'
del dic['sa']

 

字段 静态字段 普通字段
方法 静态方法（ @staticmethod 并且没有参数）类方法（@classmethod 必须有参数cls）普通方法
class Foo:
    name = '河北'   #静态字段 在类中
    @staticmethod    #静态方法
    def f2():
        print('F2')
    @classmethod      #类方法
    def f3(cls):
        print('F3')
    def __init__(self,name):
        self.name = name  #普通字段 在对象中
    def f1(self):      #普通方法   在类中
        print('F1')
print(Foo.name)  #静态字段调用
Foo.f2()  #静态方法调用
Foo.f3()   #静态方法调用
ret = Foo('alex')
print(ret.name)   #普通字段调用
ret.f1()      #普通方法调用