1.staticmethod：（静态方法）

静态方法：让类里的方法直接被类调用，就像正常的函数一样。

class Staticmethod_Demo():
    role = ‘Aray‘

    @staticmethod
    def func():
        print(‘当普通方法用‘)
Staticmethod_Demo.func()

输出结果：
当普通方法用

2.classmethod：（类方法）

类方法：默认参数为：cls  ，可以直接用类名调用，可以与类属性交互。

class Classmethod_Demo():
    role = ‘Aray‘

    @classmethod
    def func(cls):
        print(cls.role)
Classmethod_Demo.func()

输出结果：
Aray

共同点：

　　1.都可以直接被类调用，不需要实例化

不同点：

　　1,类方法必须有一个cls参数表示这这个类，静态方法不需要，不能直接被使用。

绑定方法： 普通方法   类方法

非绑定方法：  静态方法

目前为止学的方法有：

　　普通方法：默认有一个self对象传进来，并且只能被对象调用

　　类方法：默认有一个cls传进来表示本类，并且可以被类和对象调用

　　静态方法：没有默认参数，并且可以被类和对象调用。（这个方法不推荐使用）

3.isinstance

isinstance 作用是： 判断一个对象是不是这个类的对象，传两个参数，分别是对象和类，如果是，返回true，否则，为false。

class Foo:
    pass
class Son(Foo):
    pass
s = Son()  #实例化
print(isinstance(s,Son)) #判断一个对象是不是这个类的对象,传两个参数，分别是 对象和类
print(isinstance(s,Foo))
print(type(s) == Son)   #精准判断
print(type(s) == Foo)

输出结果：
True
True
True
False

4.issubclass

issubclass: 判断一个类是不是另一个类的子类，传两个参数，分别是子类和父类

class Foo:
    pass
class Son(Foo):
    pass
s = Son()  #实例化

print(issubclass(Son,Foo))  #判断一个类是不是另一个类的子类，传两个参数，分别是子类和父类
print(issubclass(Son,object))
print(issubclass(Son,Son))
print(issubclass(Foo,object))
print(issubclass(Foo,Son))

输出结果：
True
True
True
True
False

二：反射

反射：要求掌握 （多用在网络相关方面）。定义：可以用字符串的方式去访问对象的属性，调用对象的方法。

常用：

　　hasattr:

　　getattr:

hasattr和getattr通常是一起用的。一个检测，一个获取。

class Black_one:
    feature = ‘ugly‘
    def __init__(self,name,addr):
        self.name = name
        self.affr = addr

    def sell_house(self):
        print(‘%s 黑中介卖房子啦，傻逼才买呢，但是谁能证明自己不是傻逼呢？‘%self.name)
    def rent_house(self):
        print(‘%s 黑中介介绍租房子啦，傻逼才租啊‘%self.name)

b1 = Black_one(‘天地三清‘,‘道法无常‘)
#检测是否含有属性
print(hasattr(b1,‘name‘))
print(hasattr(b1,‘sell_house‘))

#获取属性
n = getattr(b1,‘name‘)
print(n)
func = getattr(b1,‘sell_house‘)
func()

print(getattr(b1,‘aaaa‘,‘不存在‘))

输出结果：TrueTrue天地三清天地三清 黑中介卖房子啦，傻逼才买呢，但是谁能证明自己不是傻逼呢？不存在

不常用：

　　setattr：

#设置属性(新增)
print(b1.__dict__)
setattr(b1,‘SB‘,True)
setattr(b1,‘time‘,‘1年‘)
print(b1.__dict__)

输出结果:{‘name‘: ‘天地三清‘, ‘addr‘: ‘道法无常‘}{‘name‘: ‘天地三清‘, ‘addr‘: ‘道法无常‘, ‘SB‘: True, ‘time‘: ‘1年‘}

　　delattr：

delattr(b1,‘addr‘)
delattr(b1,‘time‘)
print(b1.__dict__)

输出结果：
{‘name‘: ‘天地三清‘, ‘addr‘: ‘道法无常‘, ‘SB‘: True, ‘time‘: ‘1年‘}
{‘name‘: ‘天地三清‘, ‘SB‘: True}

内置方法：

str and repr

class Foo:
    def __init__(self,name):
        self.name  = name

    def __str__(self):
        return ‘%s obj info in str‘%self.name

    def __repr__(self):
        return ‘obj info in repr‘

f = Foo(‘egon‘)
print(f)
print(‘%s‘%f)
print(‘%r‘%f)

输出结果：
egon obj info in str
egon obj info in str
obj info in repr

-del-：  如果没有手动删除，系统默认最后会del。

class Foo:
    def __del__(self):
        print(‘执行我啊！‘)
f = Foo()
print(123)
print(123)
print(123)
del f
print(123)
print(123)
print(123)

输出结果：
123
123
123
执行我啊！
123
123
123

item 系列：