一, 构造方法
在使用类创建对象的时候 (就是类后面加括号) 就自动执行__init__方法.
- class A:
- def __init__(self):
- print('A')
- class B:
- def __init__(self):
- print('B')
- obj = A()
- # 虽然只是创建了 obj 对象, 但是执行了__init__方法, 输出了 A
Python 中派生类可以继承父类的构造方法
1. 基于 super()
遇到 super()就表示去执行父类的 xxx 属性
- class A:
- def __init__(self):
- print('A')
- self.tp = 'annimal'
- class B(A):
- def __init__(self):
- print('B')
- super(B,self).__init__()
- #执行 B 父类中的__init__方法, 这里的 self 是 obj
- #super 里的 self 不是传入后面的__init__方法里, 而是直接传入 A 中的__init__, 这里 super 会帮你传递参数
- obj = B()
输出结果:
B
A
2. 通过父类的名称执行父类的构造方法.
- class A:
- def __init__(self):
- print('A')
- self.tp = 'annimal'
- class B(A):
- def __init__(self):
- print('B')
- A.__init__(self)
- #父类的名称跟上__init__()
- obj = B()
输出结果:
B
A
这两种方式中推荐 super, 使用第二中方法的时候, 进行继承父类的方法的时候, 是你指定父类的方法, 看起来比较乱, 但是使用 super 的时候, 没有让你指定父类的名称, 这种继承时候就按照正常的继承规则 (上一节所讲) 来进行.
二, 反射
利用反射查看面向对象的成员
根据字符串的形式去对象 (某个模块) 操作其成员
- class Foo:
- def __init__(self,name):
- self.name = name
- def show(self):
- print('Fshow')
- r = hasattr(Foo,'show')
- print(r)
- # 查看 Foo 类中是否有 show 函数
- obj = Foo('alexsel')
- s = hasattr(obj,'name')
- print(s)
- # 查看 obj 对象里 name 是否存在
- t = hasattr(obj,'show')
- print(t)
- # 通过对象查看是否存在 show 这个函数
输出结果:
True
True
True
我们通过类进行查询的时候, 仅仅只能找到类中的属性, 但是我们通过类创建的对象查询的时候, 我们不但可以找到对象中的属性(例如, self.name, 直接在类中查询找不到), 还可以找到对象中的方法(例如 show 函数), 因为对象中有一个指向类的指针, 当通过对象进行查询的时候, 可以通过指针找到类中的属性.
利用反射导入模块, 查找类, 创建对象, 查找对象中的字段
1. 首先使用__import__导入文件
函数功能用于动态的导入模块, 主要用于反射或者延迟加载模块.
__import__(module)相当于 import module
2. 使用 getattr(所导入的文件名, 类名)导入类
getattr 根据字符串的形式去某个模块中寻找东西
3. 通过找到的类创建对象
4. 获取对象中的属性
s2.py 文件中的代码
- class Foo:
- def __init__(self,name):
- self.name = name
- def show(self):
- print('Fshow')
s1.py 文件中的代码
- m = __import__('zp')
- class_name = getattr(m,'Foo')
- obj = class_name('Alexsel')
- val = getattr(obj,'name')
- print(val)
输出结果:
Alexsel
三, 静态字段
静态字段的作用, 将每个对象里存在的重复的东西, 使用静态字段在类中只需写一份.
- class Foo:
- annimal = 'Cat'
- #这个是静态字段, 是在类中保存的
- def __init__(self,name):
- temp = 'Alexsel'
- #普通字段, 存放在对象中
- #普通方法, 存放在类中
- def show(self):
- print('SH')
- print(Foo.annimal)
输出结果:
Cat
使用静态字段的时候, 优先使用类名访问静态字段.
四, 静态方法
静态方法是类中的函数, 不需要实例. 静态方法主要是用来存放逻辑性的代码, 主要是一些逻辑属于类, 但是和类本身没有交互, 即在静态方法中, 不会涉及到类中的方法和属性的操作.
- class Foo:
- annimal = 'Cat'
- def __init__(self):
- pass
- def show(self):
- print('SH')
- #装饰器, 使用这个装饰器装饰类中的一个方法, 这个方法就变为静态方法
- @staticmethod
- def out():
- print('out')
- Foo.out()
- # 静态方法中不需要传递 self, 所以访问静态方法优先使用类去访问
- obj = Foo()
- obj.out()
输出结果:
out
out
静态方法可以让我们不需要创建对象就可以执行类中的方法.
五, 类方法
类方法是将类本身作为对象进行操作的方法. 他和静态方法的区别在于: 不管这个方式是从实例调用还是从类调用, 它都用第一个参数把类传递过来.
- class Foo:
- annimal = 'Cat'
- def __init__(self):
- pass
- def show(self):
- print('SH')
- #装饰器, 使用这个装饰器装饰类中的一个方法, 这个方法就变为类方法
- @classmethod
- def out(cls):
- print('out',cls)
- Foo.out()
- # 类方法, 会自动将的类传递到类方法的 cls 中
输出结果:
out <class '__main__.Foo'>
来源: https://www.cnblogs.com/liudi2017/p/9357613.html