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
<class 'dddoc.Dog'>

• __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__': <function Dog.__init__ at 0x0000023D6B82F620>,
'__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': None, '__dict__': <attribute '__dict__' of 'Dog' objects>,'eat': <property object at 0x0000023D6B8504A8>, '__call__': <function Dog.__call__ at 0x0000023D6B82F840>, '__module__': '__main__'}

# 打印所有实例属性，不包括类属性
d = Dog("duoduo")
print( d.__dict__)

• __str__
  如果一个类中定义了 __str__ 方法，那么在打印对象时，默认输出该方法的返回值。

类Dog中加入方法：
    def __str__(self):
        return "<obj:%s>"  % self.name
调用：
d = Dog("duoduo")
print(d)
结果：
<obj:duoduo>
分析：
原始    应该是个函数地址
<__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))
   
结果：
<class '__main__.Foo'>
<class 'type'>

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
<class 'type'>

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 
<class 'type'>

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

整个过程演示