静态方法：
通过 @staticmethod 装饰器即可把其装饰的方法变为一个静态方法。普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法
示例：
class Dog(object):
def __init__(self, name):
self.name = name
@staticmethod
def eat_static(food): # 不能传入 self 否则会报错
print(' is eating %s' % food)
def eat(self, food):
print('%s is eating %s' % (self.name, food))
d = Dog('A dog')
d.eat_static('bone') # 调用静态方法
d.eat('bone')
输出结果：
is eating bone
A dog is eating bone
类方法：
类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量
示例：
class Dog(object):
name = 'Dog' # 类变量 def __init__(self, name):
self.name = name @classmethod
def eat_class(cls, food): # 不能传入 self 否则会报错
print('%s is eating %s' % (cls.name, food)) def eat(self, food):
print('%s is eating %s' % (self.name, food)) d = Dog('A dog')
d.eat_class('bone') # 调用类方法
d.eat('bone')
输出结果：
Dog is eating bone
A dog is eating bone
属性方法：
属性方法的作用就是通过 @property 把一个方法变成一个静态属性
简单使用示例：
class Dog(object):
def __init__(self, name):
self.name = name
@property
def eat(self):
print("%s is eating" % self.name)
d = Dog("A dog")
d.eat # 调用属性(无法直接传参数)，加括号会报错
输出结果：
A dog is eating
给属性方法赋值
示例：
class Dog(object):
def __init__(self, name):
self.name = name
@property
def eat(self):
print("%s is eating" % self.name)
@eat.setter
def eat(self, food): # 当给属性方法赋值时，调用这个方法
print('The food is %s' % food)
d = Dog("A dog")
d.eat
d.eat = 'bone'
输出结果：
A dog is eating
The food is bone
如果希望属性方法有参数，需要将参数存为类变量
示例：
class Dog(object):
def __init__(self, name):
self.name = name
self.__food = None
@property
def eat(self):
print("%s is eating %s" % (self.name, self.__food))
@eat.setter
def eat(self, food):
print('The food is %s' % food)
self.__food = food
d = Dog("A dog")
d.eat
d.eat = 'bone'
d.eat
输出结果：
A dog is eating None
The food is bone
A dog is eating bone
删除属性方法只需在上面函数的基础上再写一个：
@eat.deleter
def eat(self):
del self.__food
之后再调用 self.__food属性时就会报错，已经找不到了。
类的特殊成员方法：
1.__doc__：表示类的描述信息
class Dog(object):
'''这个类是用来描述狗这个对象的'''
def __init__(self):
pass print(Dog.__doc__)
输出结果：
这个类是用来描述狗这个对象的
2.__module__、 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
lib\aa.py:
class C(object):
def __init__(self, name):
self.name = name
index.py:
from lib.aa import C
obj = C('name')
print(obj.__module__)
print(obj.__class__)
输出结果：
lib.aa
<class ’lib.aa.C’>
3.__init__：构造方法
4.__del__：析构函数
5.__call__:对象后面加括号，触发执行
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
Foo()()
输出结果：
__call__
__call__
6__dict__
通过类调用：查看类里的所有属性(不包括实例里的)
通过实例调用：查看实例里的所有属性(不包括类里的)
通过字典储存类中所有属性，绑定动态属性时也会在字典中添加相应项。占用内存较大，当存在大量实例时会占用大量资源，可以通过 '__slots__' 解决 <--点击查看
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo()
print(Foo.__dict__)
print(obj.__dict__)
输出结果：
{'__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__module__': '__main__', '__init__': <function Foo.__init__ at 0x000001CED095D378>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, '__call__': <function Foo.__call__ at 0x000001CED3A9B510>}
{}
7.__str__：如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值
不使用__str__时：
class Foo(object):
def __init__(self, name):
self.name = name
obj = Foo('A obj')
print(obj)
输出结果：
<__main__.Foo object at 0x0000024051A5F0F0>
如果加上__str__：
class Foo(object):
def __init__(self, name):
self.name = name
def __str__(self):
return '<obj:%s>' % self.name
obj = Foo('obj name')
print(obj)
输出结果：
<obj:A obj>
8.__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
class Foo(object):
def __getitem__(self, key):
print('__getitem__', key)
def __setitem__(self, key, value):
print('__setitem__', key, value)
def __delitem__(self, key):
print('__delitem__', key)
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'name' # 自动触发执行 __setitem__
del obj['k1'] # 自动触发执行 __delitem__
输出结果：
__getitem__ k1
__setitem__ k2 name
__delitem__ k1
9.__new__ 、__metaclass__
先看一段代码：
class Foo(object):
def __init__(self, name):
self.name = name
f = Foo("name")
print(type(f))
print(type(Foo))
输出结果：
<class '__main__.Foo'>
<class 'type'>
所以，f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建
类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。
自定义元类：
class MyType(type):
def __init__(cls, *args, **kwargs): print("Mytype __init__", *args, **kwargs) def __call__(cls, *args, **kwargs):
print("Mytype __call__", *args, **kwargs)
obj = cls.__new__(cls)
print("obj ", obj, *args, **kwargs)
print(cls)
cls.__init__(obj, *args, **kwargs)
return obj def __new__(mcs, *args, **kwargs):
print("Mytype __new__", *args, **kwargs)
return type.__new__(mcs, *args, **kwargs) print('here...') class Foo(object, metaclass=MyType):
def __init__(self, name):
self.name = name print("Foo __init__") def __new__(cls, *args, **kwargs):
print("Foo __new__", cls, *args, **kwargs)
return object.__new__(cls) f = Foo("Name")
print("f", f)
print("fname", f.name)
类的生成 调用 顺序依次是 __new__ --> __init__ --> __call__