>>> n1 = 10
>>> isinstance(n1, int) #判断n1是否是数字类型,如果是返回True如果不是防护False
True

>>> class A(object):
...     pass
...
>>> a1 = A()
>>> isinstance(a1, A)  # 判断a1是否是类A的对象，如果是返回True，如果不是返回False
True

>>> print(type(1) is int)
True
>>> print(isinstance(1, int))
True

#从上面的结果看，两者的结果都是True，那么type()与isinstance()的区别在哪呢？
#从接下来的例子，就能够清晰看出来。

class A:pass
class B(A):pass

b = B()

print(isinstance(b, A)) # True
print(isinstance(b, B)) # True

print(type(b))  # <class '__main__.B'>
print(type(b) is B) # True
print(type(b) is A) # False

#总结：
    isinstance()是可以用在继承的关系上；而type()不能用来检测继承关系。

class A:pass
class B(A):pass

print(issubclass(B, A)) # True
print(issubclass(A, B)) # False

# 总结：
    类B是类A的子类，类A不是类B的子类

class A:
    name = "小白"
    age = 18

    def func(self):
        print("in the func")

print(A.name)
print(A.age)

# 使用反射的形式,操作类的属性
print(getattr(A, 'name'))

# 使用反射操作类中的方法
a = A()
ret = getattr(a, 'func')    # 得到了func方法的内存地址
ret()       # 调用func（）方法

# 例子1：通过hasattr判断，再用getattr来取值。
class A:
    name = "xiao"
    age = 18

inpu = input('>>>: ')
if hasattr(A, inpu):
    print(getattr(A, inpu))
else:
    print("A类中没有对应的属性")

>>>: name
xiao
>>>: sex
A类中没有对应的属性

# 例子2：
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        for key in self.__dict__:           #__dict__查看对象的所有属性
            print(key, self.__dict__[key])  # key self.__dict__[key]

stu1 = Student("小白", 18)
if hasattr(stu1, 'show'):
    func = getattr(stu1, 'show')     # 返回方法的内存地址,赋值给func()
    func()

name 小白
age 18

# 正常情况下，想给对象设置一个值。
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        for key in self.__dict__:
            print(key, self.__dict__[key])

stu1 = Student("小白", 18)
stu1.name = "小黄"
print(stu1.name)    # 小黄


# 除了上面的方式之外，还有一种方式为对象设置属性，通过反射的形式.
setattr(stu1, 'name', '菜农')
print(stu1.__dict__)    # {'name': '菜农', 'age': 18}
print(stu1.name)    # 菜农

# 创建一个函数，通过setattr给对象绑上这个函数
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        for key in self.__dict__:
            print(key, self.__dict__[key])

stu1 = Student("小白", 18)

def func():
    print('In func')

setattr(stu1, 'func1', func)
stu1.func1()        # In func
print(stu1.__dict__)    # {'name': '小白', 'age': 18, 'func1': <function func at 0x00000226123740D0>}

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

    def show(self):
        for key in self.__dict__:
            print(key, self.__dict__[key])


stu1 = Student("小白", 18)
# 正常方法
del stu1.name
print(stu1.__dict__)    # {'age': 18}

# 通过delattr反射的方式
delattr(stu1, 'name')
print(stu1.__dict__)    # {'age': 18}

class Student(object):
    name = "小白"

    @classmethod
    def check_course(cls):
        print("查看课程")

    @staticmethod
    def login():
        print("登录")

# 检查是否含有某属性
print(hasattr(Student, "login"))    # 检测Student类中是否有login方法，如果有返回True，没有返回False

# 通过反射查看静态属性
print(getattr(Student, 'name'))

# 通过反射调用方法
print(getattr(Student, "check_course"))  # 得到的是类方法的内存地址
getattr(Student, "check_course")()  # 调用类方法
print(getattr(Student, "login"))    # 得到的是静态方法的内存地址
getattr(Student, "login")() # 调用静态方法

# 一般情况hasattr和getattr联用， 示例：
num = input('>>>')  # 等待用户输入
if hasattr(Student, num):   # 判断用户输入的方法是否有，如果有才执行。
    getattr(Student, num)()

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

    def func(self):
        print(" In func ")


a = A("小白")
print(a.name)
print(getattr(a, "name"))
getattr(a, "func")()

import os
os.rename('__init__.py', 'init')
getattr(os, 'rename')('init', '__init__.py')    # os.rename('init', '__init__.py')

import sys
def wahaha():
    print("wahaha")

def qqxing():
    print("qqxing")

wahaha()
qqxing()

my_file = sys.modules['__main__']

getattr(my_file, 'wahaha')()
getattr(my_file, 'qqxing')()

#通过sys.modules[__name__]反射当前模块<br>import sys
import sys
def func():
    print("本模块函数func")

getattr(sys.modules[__name__], 'func')()    # 本模块函数func

# 反射
# hasattr, getattr
# 类名.名字
    # getattr(类名, '名字')
# 对象名.名字
    # getattr(对象, '名字')
# 模块名.名字
    # import 模块
    # getattr(模块, '名字')
# 自己文件.名字
    # import sys
    # getattr(sys.modules[__main__], '名字')

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

    def __call__(self, *args, **kwargs):
        print('调用对象的__call__方法')


a = Person('张三', 24)  # 类Person可调用
a()  # 对象a可以调用

class A(object):
    def __call__(self, *args, **kwargs):
        print("执行了call方法")


class B(object):
    def __init__(self, cls):
        print("在实例化A之前做一些事情")
        self.obj = cls()
        self.obj()
        print("在实例化A之后做一些事情")


a = A()
a()     # 对象() == 相当于调用__call__方法

A()()   # 类名()() 相当于先实例化得到了一个对象，再对对象(), ==> 和上面的结果一样，相当于调用__call__方法
B(A)

class Foo(object):
    def __init__(self, s):
        self.s = s

    def __len__(self):
        print('调用了__len__方法， 计算长度')
        return len(self.s)


a = Foo("aaaa")
print(len(a))   # 自动调用了__len__方法
'''
打印结果：
调用了__len__方法， 计算长度
4
'''

class Fuu():
    def __new__(cls, *args, **kwargs):  # 构造方法，构造了对象的空间
        print("执行了__new__方法")
        return object.__new__(cls)  # 或者super().__new(cls) # 调用了object类中的__new__方法

    def __init__(self, name, age):  # 初始化方法
        print("执行了init方法")
        self.name = name
        self.age = age


c1 = Fuu("小白", 18)
"""
就这样执行可以打印出：
执行了__new__方法
执行了init方法
"""

# 单例模式：一个类只有一个实例。
# 思考：如果使得一个类只能实例化一次，也就是这要控制只能开辟一次空间，就能实现单例模式。


class Singleinstance():
    __INSTANCE = None   # 通过设置一个标志位，用来使得只能运行一次new方法

    def __new__(cls, *args, **kwargs):
        if not cls.__INSTANCE:
            cls.__INSTANCE = object.__new__(cls)
        return cls.__INSTANCE

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

obj1 = Singleinstance('小白', 18)
obj2 = Singleinstance('小黑', 20)

print(obj1.name, obj1.age)
print(obj2.name, obj2.age)
print(obj1)
print(obj2)

>>>
小黑 20
小黑 20
<__main__.Singleinstance object at 0x000001C1657F6048>
<__main__.Singleinstance object at 0x000001C1657F6048>

'''
总结：由上打印可以看到不论实例化多少对象，都是一个对象，都会已最后一个为准。
'''

class Student:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __str__(self):
        return "%s %s %s" % (self.name, self.age, self.sex)

st1 = Student("小白", 18, "男")
print(st1)                  #1.打印对象名，自动触发__str__方法
>>>
小白 18 男


student_list = []
student_list.append(st1)
for index, i in enumerate(student_list):
    print('%s %s'% (index, i))          #2.当使用%s格式化的时候，自动触发__str__

>>>
0 小白 18 男

# (1)同时存在__str__和__repr__两个方法：
class Student:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __str__(self):
        return "str: %s %s %s" % (self.name, self.age, self.sex)

    def __repr__(self):
        return "repr: %s %s %s" % (self.name, self.age, self.sex)


st1 = Student("小白", 18, "男")
print(st1)
>>>
str: 小白 18 男


# (2)只存在__repr__方法时，再次打印对象名：
class Student:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    # 注释掉__str__双下方法
    # def __str__(self):
    #     return "str: %s %s %s" % (self.name, self.age, self.sex)

    def __repr__(self):
        return "repr: %s %s %s" % (self.name, self.age, self.sex)


st1 = Student("小白", 18, "男")
print(st1)         # 当__str__没有时，执行__repr__方法
>>>
repr: 小白 18 男

st1 = Student("小白", 18, "男")
print(repr(st1))
>>>
repr: 小白 18 男

__str__=__repr__