Python 8（静态/类/属性方法，类的特殊成员方法 ）
本节内容
- 静态方法，类方法，属性方法
- 深入类的特殊成员方法__init__()等
静态方法
- 只是名义上归类管理，实际上在静态方法里访问不了类或实例中的任何属性
- 例1
结果
不再像之前的实例方法，默认传入self - 例2
结果
- 总结
静态方法需要传入具体对象，这样才能使用其属性。
类方法
- 只能访问类变量，不能访问实例变量
- 例1
结果
- 例2
结果
- 例3
调用方式也可以直接用 “类.方法名（）”
属性方法
- 把一个方法变成一个静态属性
- 例1
结果
总结
只能作为属性，无法传入参数 - 例2
结果
- 例3 直接给属性赋值 no ok
结果
- 例4 利用私有属性进行赋值 ok
结果
- 例5 想要删除属性方法 del not ok
- 例6 真正的方法 再写一个方法 内部删除
结果
再调用一次d.eat的结果
- 总结作用
1 把一个方法变成静态属性，而非定义成一个静态变量，很多场景用到，如想知道一个航班当前的状态，是到达了，延迟了，取消了，还是已经飞走了，得经过下面几步：
1）连接航空公司的API查询
2） 对查询结果进行解析
3） 返回结果给你的用户
2 故此 status属性的值是一系列动作之后才得到的结果，每次调用其实都要经过一系列动作返回结果，但这些动作过程不需要用户关心，用户只需要调用这个属性就可以。
3 以查询航班状态为例
用户查询（不需要关心查询的具体细节）：
f = Flight("CA230")
f.Flight_status = ?
中间商（根据不同状态码进行解析 返回给用户说明）：
航空公司（检查状态）：
这里简化 直接return 1
类的特殊成员方法
__doc__表示类的描述信息
class Foo:
'''这个类是用来描述 xxx信息'''
def func(self):
pass
print(Foo.__doc__)
# 输出 ：类的描述信息
__module__ 和 __class__
__module__表示当前操作的对象在哪个模块
__class__表示当前操作的对象的类是什么
# dddoc.py文件
class Dog(object):
'''这个类是描述狗的信息'''
def __init__(self):
self.name = "wufdjdh"
def call(self):
print("dog is calling ")
# 另一个文件
from dddoc import Dog
obj = Dog()
print(obj.__module__)
print(obj.__class__）
结果
这个类是描述狗的信息
dddoc
-
__init__构造方法
通过类创建对象时自动触发执行 -
__del__
析构方法：当对象在内存中被释放时，自动触发执行
ps: 此方法一般无须定义，因为Python 是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作交给Python解释器来执行。所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。 -
__call__
对象后面加括号，触发执行
ps: 构造方法的执行是由创建对象触发的，即 对象=类名（）
对于__call__方法的执行是由对象后加括号触发的，即 对象（） 或者 类()()
XXX 正常的Dog类
d = Dog("duoduo")
d()
结果
TypeError: 'Dog' object is not callable
需要改正
在class Dog中加入方法
def __call__(self, *args, **kwargs):
print("running call",args,kwargs)
调用
d = Dog("duoduo")
d() / Dog("duoduo")（）
结果
running call () {}
也可以传入参数
__dict__查看类或对象中的所有成员
# 打印类里的所有属性，不包括实例属性
print(Dog.__dict__)
结果
{'__init__': ,
'__weakref__': , '__doc__': None, '__dict__': ,'eat': , '__call__': , '__module__': '__main__'}
# 打印所有实例属性，不包括类属性
d = Dog("duoduo")
print( d.__dict__)
__str__
如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值。
类Dog中加入方法：
def __str__(self):
return "" % self.name
调用：
d = Dog("duoduo")
print(d)
结果：
分析：
原始 应该是个函数地址
<__main__.Dog object at 0x0000020D5B070208>
__new__
1 在Python中一切事物都是对象
class Foo(object):
def __init__(self ,name):
self.name = name
obj = Foo("duoduo")
obj对象是通过执行Foo类的构造方法创建，那么Foo类对象是通过 type 类的构造方法创建
调用：
print(type(obj))
print(type(Foo))
结果：
2 通过type创建对象并调用方法
type称作 类的类
# 普通方式
class Foo(object):
def func(self ):
print( "hello duoduo")
# 特殊方式
def func(self):
print("hello duoduo")
Foo = type('Foo',(object,),{'fun':func})
# type第一个参数：类名
# type第二个参数：当前类的基类
# type 第三个参数：类的成员
f = Foo()
f.fun()
print(type(Foo))
结果
hello duoduo
3 加入初始化函数及参数
def func(self):
print("hello %s " %self.name)
def __init__(self,name,age):
self.name = name
self.age = age
print("init is finished")
Foo = type('Foo',(object,),{'func':func,
'__init__':__init__})
f = Foo("dd",22)
f.func()
结果
init is finished
hello dd
ps：__init__ 函数的名称必须为__init__ ，否则无法自动调用，而其他功能函数名称则随意，只要构成字典即可。
4 一些概念的梳理
类是由type类实例化产生
那么type类中如何实现创建类？
答：类中有一个属性`__metaclass__`用来表示该类由 谁 来实例化创建
class MyType(type):
def __init__(self, what, bases=None, dict=None):
print("----MyType init---")
super(MyType, self).__init__(what, bases, dict)
def __call__(self, *args, **kwargs):
print("---MyType---call")
obj = self.__new__(self, *args, **kwargs)
self.__init__(obj, *args, **kwargs)
class Foo(object):
__metaclass__ = MyType
def __init__(self, name):
self.name = name
print("Foo __init__")
def __new__(cls,*args,**kwargs):
print("Foo --- new---")
print(object.__new__(cls))
return object.__new__(cls)
# 第一阶段：解释器从上到下执行代码创建Foo类
# 第二阶段：通过Foo类创建obj对象
obj = Foo("duduo")
结果
可以看到大概的顺序
父init—>call调用new---->new 再调用init
整个过程演示
