isinstance和issubclass

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
    pass


obj = Foo()
# true
print(isinstance(obj, Foo))

issubclass(sub, super)检查sub类是否是 super 类的派生类 

class Foo(object):
    pass


class Bar(Foo):
    pass


# true Bar类继承Foo类
print(issubclass(Bar, Foo))
class Foo(object):
    pass


class Bar(Foo):
    pass


# true Bar类继承Foo类
print(issubclass(Bar, Foo))

反射进阶

# 反射 ： 是用字符串类型的名字 去操作 变量
# name = 1
# eval('print(name)')  # 安全隐患

# 反射 就没有安全问题

# 反射 ： 是用字符串类型的名字 去操作 变量


# 反射对象中的属性和方法   # hasattr getattr setattr delattr
# class A:
#     def func(self):
#         print('in func')
#
# a = A()
# a.name = 'alex'
# a.age = 63
# # 反射对象的属性
# ret = getattr(a,'name')  # 通过变量名的字符串形式取到的值
# print(ret)
# print(a.__dict__)
# 变量名 = input('>>>')   # func
# print(getattr(a,变量名))
# print(a.__dict__[变量名])
#
# # 反射对象的方法
# a.func()
# ret = getattr(a,'func')
# ret()
#
# class A:
#     price = 20
#     @classmethod
#     def func(cls):
#         print('in func')
# # 反射类的属性
# # A.price
# print(getattr(A,'price'))
#
# # 反射类的方法 ：classmethod staticmethod
# # A.func()
# if hasattr(A,'func'):
#     getattr(A,'func')()

# 模块
# import my
# 反射模块的属性
# print(my.day)
# print(getattr(my,'day'))

# 反射模块的方法
# getattr(my,'wahaha')()

# 内置模块也能用
# time
# asctime
# import time
# print(getattr(time,'time')())
# print(getattr(time,'asctime')())

# def qqxing():
#     print('qqxing')
# year = 2018
# import sys
# # print(sys.modules['__main__'].year)
# # 反射自己模块中的变量
# # print(getattr(sys.modules['__main__'],'year'))
#
# # 反射自己模块中的函数
# # getattr(sys.modules['__main__'],'qqxing')()
# 变量名 = input('>>>')
# print(getattr(sys.modules[__name__],变量名))

# 要反射的函数有参数怎么办?
# print(time.strftime('%Y-%m-%d %H:%M:S'))
# print(getattr(time,'strftime')('%Y-%m-%d %H:%M:S'))

# 一个模块中的类能不能反射得到
# import my
# print(getattr(my,'C')())
# if hasattr(my,'name'):
#     getattr(my,'name')

# 重要程度半颗星
# setattr  设置修改变量
class A:
    pass


a = A()
setattr(a, 'name', 'nezha')
setattr(A, 'name', 'alex')
print(A.name)
print(a.name)

# delattr 删除一个变量
delattr(a, 'name')
print(a.name)
delattr(A, 'name')
print(a.name)

类的内置方法

# 内置的类方法 和 内置的函数之间有着千丝万缕的联系
# 双下方法

class Teacher:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def __str__(self):  # 相当于java中的toString()方法
        return "Teacher's object :%s" % self.name

    def __repr__(self):
        return str(self.__dict__)

    def func(self):
        return 'wahaha'


nezha = Teacher('哪吒', 250)
print(nezha)  # 打印一个对象的时候，就是调用a.__str__
print(repr(nezha))
print('>>> %r' % nezha)


# a.__str__ --> object
# object  里有一个__str__，一旦被调用，就返回调用这个方法的对象的内存地址
# %s str()  直接打印 实际上都是走的__str__
# %r repr()  实际上都是走的__repr__
# repr 是str的备胎，但str不能做repr的备胎

# print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
# 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。
# repr(),只会找__repr__,如果没有找父类的

# 内置的方法有很多
# 不一定全都在object中
# class Classes:
#     def __init__(self,name):
#         self.name = name
#         self.student = []
#     def __len__(self):
#         return len(self.student)
#     def __str__(self):
#         return 'classes'
# py_s9= Classes('python全栈9期')
# py_s9.student.append('二哥')
# py_s9.student.append('泰哥')
# print(len(py_s9))
# print(py_s9)

# __del__
# class A:
#     def __del__(self):   # 析构函数: 在删除一个对象之前进行一些收尾工作
#         self.f.close()
# a = A()
# a.f = open()   # 打开文件 第一 在操作系统中打开了一个文件 拿到了文件操作符存在了内存中
# del a          # a.f 拿到了文件操作符消失在了内存中
# del a   # del 既执行了这个方法，又删除了变量
# 引用计数


# __call__
class A:
    def __init__(self, name):
        self.name = name

    def __call__(self):
        '''
        打印这个对象中的所有属性
        :return:
        '''
        for k in self.__dict__:
            print(k, self.__dict__[k])


a = A('alex')()

__call__

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()  # 执行 __init__
obj()  # 执行 __call__