python 常用方法

　　在python的类中，除了常规的一些自定义函数调用之外还有一些内置函数或方法，大多数情况下不会用到，但是为了更好的学习到python类的原理也需要对其有一定的了解，下面我们一起来看一下都具体包含了那些内容。

 

1 静态方法

　　@staticmethod 本质为装饰器，可以理解为：名义归类管理，但实际上在静态方法里访问不了类或示例中的任何属性，相当于装饰成了类的高级工具包。

2 类方法

　　@classmethod 本质为装饰器，只能访问类变量，不能访问示例变量。

__Author__ = "Panda-J"

class Person(object):
    name = "Shuaige"
    def __init__(self,name):
        self.name = name
        print("this is %s name"%name)
    @classmethod
    def Test_method(self):
        print("%s is this name."%self.name)
Person.Test_method()
Person("Meinv")
    

3 属性方法

　　@property 本质为装饰器，把一个方法变成一个静态属性，不能在后面加括号进行调用。如果必须传参数进行调用的话必须引入一个相同名字的函数，并加上@[name].setter装饰器中进行参数传递。属性方法是无法进行删除。删除用@[name].deleter中使用del命令才能删除

@property
    def eat(self):
        print("I love eat",self.__food)
    @eat.setter
    def eat(self,food):
        print("set food :",food)
        self.__food = food
    @eat.deleter
    def eat(self):
        del self.__food
        print("删完了")

p.eat#此处不需要加括号进行调用
p.eat="baozi"#将“baozi”传进了__food中，调用了@eat.setter函数
p.eat

　　

 4 特殊成员方法

　　__doc__:储存类下用于注释该类的用法的内容。

class Person(object):
    '''这是描述人类基本信息的类'''
print(p.__doc__)

　　__module__:表示当前操作的对象在哪个模块中；__class__:表示当前操作的对象在哪个类中。

　　__init__：构造方法，通过创造对象时，自动执行

　　__del__:析构方法，当对象在内存中释放的时候将自动执行析构方法。

　　__call__:可调用函数，使该对象具有可调用的功能。即相当于是该类可以使用两个括号进行引用，执行call中的语句：Person()()

class Person(object):
    def __call__(self, *args, **kwargs):
        print("your are great",args,kwargs,"thanks for your hardworking")
p = Person("Jiang")
p("Jiang","Lirui")

　　__dict__:调用前表示该类所具有的所有属性。调用后表示该示例所具有的属性

print(Person.__dict__)
p = Person("Jiang")
print(p.__dict__)

　　__str__:返回一个值而不是地址

    def __str__(self):
        print("<welcome>",self.name)
print(p)

　　__getitem__\__setitem__\__delitem__:此类方法最大的好处就在于可以将一个实例封装（伪装）成一个字典，用户调用和字典的方式完全一样，可以在类中加入限制调用以及更多的操作方法，丰富“字典”的使用方法。

    def __getitem__(self, item):
        print("this running getitem %s progress"%item)
        return self.data.get(item)
    def __setitem__(self, key, value):
        self.data[key] = value
    def __delitem__(self, key):
        del self.data[key]
p = Person("Jiang")
p["look"] = "perfomanced"
p["smell"] = "good"
print(p["look"])
del p["look"]
print(p.data)

　　

　　type:装逼的类创建,从此也可以看出Person即为type的一个示例（对象），也是一个类，所以type可以成为“类的类“。可以

　

def func(self):
    print("this is a function")


def __init__(self, name, age):
    self.name = name
    self.age = age


Person = type("Person", (object,), {"func_name": func,
                                    "__init__": __init__})  # 进行一个类的创建
p = Person("Jiang", 24)
p.func_name()

　　

　　__new__:可以自己封装一个类（对类的自定义化），__new__先于__init__执行。在python2.x中是由__call__函数创建。创建new的时候一定注意需要返回一个”cls“用于创建类。如果没有return将不会创建一个真正的实例

 

    def __new__(cls, *args, **kwargs):
        print("this is new",args)
        return object.__new__(cls)#继承父亲的__new__方法。

　　__metacalss__:是一个很神奇的函数---元类。在python2.x的版本中可以看出差别，在3.x中有所区别。感兴趣的朋友可以试一下。用这个的目的就是为了自定义类，而不是按照系统默认的方法进行类的创建。

class Mytype(type):#定义一个元类
    def __init__(self,what,base=None,dict=None):#重构init，加入自定义功能。
        print('=======This is Mytype init=======')
        super(Mytype,self).__init__(what,base,dict)#继承init，可正常实例化。
    def __call__(self, *args, **kwargs):
        print('=====This is Mytype call=====')
        # obj=self.__new__(self,*args,**kwargs)
        # self.__init__(obj,*args,**kwargs)

class Person(object):
    __metaclass__=Mytype#该对象以Mytype定义的形式进行创建
    def __init__(self,name):
        self.name = name
        print("--Init the %s Person"%name)
    def __new__(cls, *args, **kwargs):
        print("--Person new %s"%args)
        return object.__new__(cls)
p = Person("Jiang")

　　

　　在python2.x中执行的效果就是这样：

　　由此可以看出是先执行了Mytype中自定义类的程序，再执行了Foo类的创建程序。详情请参阅StackOverflow上的链接。

在类方法中一个比较重要的来了

4 反射：

　　1 hasattr(obj,name_str)--判断一个对象是否由对应(name_str)的字符串方法，有返回True，无返回False

　　2 getattr(obj,name_str)--获得该字符串对应的函数/方法的内存方法

　　3 setattr('x','y','v')--相当于x.y=v,但不等于，无法直接使用x.y。会提示在x中找不到y方法。可赋值给一个变量a=getattr(x,y)，让变量去调用函数a()。动态的内存交互。

　　4 delattr(obj,name_str)--删除obj中的name_str方法。

所有的方法都在下面的代码中使用，请参考：

def bulk(self):
    print("%s is yelling"%self.name)#self.name用的就是Person里的self.name
class Person(object):
    def __init__(self,name):
        self.name = name#类的结构化
    def eat(self,food):
        print("%s is eating %s"%(self.name,food))

d = Person("Jiang")
print(d.name)
choice = input(">>".strip())#输入一个属性
if hasattr(d,choice):#判断是否具有“choice”
    func = getattr(d,choice)#将d.choice的地址赋值给func
    func("Banana")#对d.choice的调用
    delattr(d, choice)#删除choice这个属性
else:
    setattr(d,choice,bulk)#将bulk方法归在类下
    c = getattr(d,choice)#将d.choice的地址赋值给c
    c(d)#调用c
print(d.name)