反射 内置方法

标签：sys   静态   input   模块   __str__   call()   str   magic   __call__   

# isinstance()判断对象所属类型,包括继承关系  判断对象
# class A:pass
# class B(A):pass
# b=B()
# print(isinstance(b,B))# b属于 B
# print(isinstance(b,A))# b属于 A
#
#ssubclass()  判断类与类之间的继承关系
# class A:pass
# class B(A):pass
# print(issubclass(B,A))# b属于 B
# print(issubclass(A,B))# A不属于 B

# 反射:用字符串数据类型的变量名来访问这个变量的值
# 类   静态属性,类方法 ,静态方法
#命名空间  xxx=getattr(命名空间,‘xxx)
class Student:
    ROLE=‘STUDENT‘
    @classmethod
    def check_course(cls):
        print(‘查看课程‘)
    @staticmethod
    def login():
        print(‘登陆‘)
# 反射查看属性
# print(Student.ROLE)
# print(getattr(Student,‘ROLE‘))

#反射调用方法
# getattr(Student,‘check_course‘)() # 类方法
# getattr(Student,‘login‘)()  # 静态方法

# num=input(‘>>>>‘)
# if hasattr(Student,num):
#     getattr(Student,num)()

#对象  方法 对象属性
# class A():
#     def __init__(self,name ):
#         self.name=name
#
#     def func(self):
#         print(‘in func‘)
# a=A(‘alex‘)
# # print(a.name)
# # print(getattr(a,‘name‘))
# getattr(a,‘func‘)()
# 模块

# import os #  别人写好的python代码的结合
# os.rename(‘2442‘,‘1‘)
# getattr(os,‘rename‘)(‘1.py‘,‘1.txt‘)
# rename = os.rename
# getattr(os,‘rename‘)(‘1.txt‘,‘2.txt‘)
#
# def jj():
#     print(‘jj‘)
# def hh():
#     print(‘hh‘)
# # jj()
#
# import sys
# a=sys.modules[‘__main__‘]
# getattr(a,‘jj‘)()
# getattr(a,‘hh‘)()


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

# __名字__
    # 类中的特殊方法\内置方法
    # 双下方法
    # 魔术方法   magic_method
# 类中的每一个双下方法都有它自己的特殊意义

# __call__ 相当于 对象()
# __len__  len(obj)
# __new__  特别重要   开辟内存空间的 类的构造方法
    # 写一个单例类=
# __str__  str(obj),‘%s‘%obj,print(obj)

# 所有的双下方法 没有 需要你在外部直接调用的
# 而是总有一些其他的 内置函数 特殊的语法 来自动触发这些 双下方法

#__call__
# class A:
#     def __call__(self, *args, **kwargs):
#         print(‘执行call方法‘)
#     def call(self):
#         print(‘执行call方法1‘)
# class B:
#     def __init__(self,cls):
#         # print(‘在实例化A之前做一些事‘)
#         self.a=cls()
#         self.a()
#         print(‘在实例化A之后做一些事情11‘)
# a=A()
# a()   # 对象() == 相当于调用__call__方法
# A()()
# a.call()
# B(A)


 # __len__
# 内置函数和类的内置方法是由奸情的
# class A:
#     def __init__(self):
#         self.l=[1,2,1,2,3,1]
#         self.name=‘qwe‘
#         self.age=85
#     def __len__(self):
#         print(‘执行__len__‘)
#         return  len(self.__dict__)
# a=A()
# print(len(a))
# len(obj)相当于调用了这个obj的__len__方法
# __len__方法return的值就是len函数的返回值
# 如果一个obj对象没有__len__方法,那么len函数会报错

#  练习
# 类
# self.s = ‘‘
# len(obj) = str的长度
# class A:
#     def __init__(self,s):
#         self.s=s
#     def __len__(self):
#         return  len(self.s)
# a=A(‘qweqwe‘)
# print(len(a))

# iter和next的例子
# __iter__  iter(obj)
# __next__  next
# def iter(obj):
#     return obj.__iter__()
# l = [1,2,3]
# iter(l) # l.__iter__()

# __new__    # ==> 构造方法
# __init__  # ==> 初始化方法

# class Single:
#     def __new__(cls, *args, **kwargs):
#         obj=obj.__new__(cls)
#         print(‘在new方法里‘,obj)
#         return obj
#     def __init__(self):
#         print(‘在init方法里‘, self)
# 1.开辟一个空间,属于对象的
# 2.把对象的空间传给self,执行init
# 3.将这个对象的空间返回给调用者
# obj = Single()
# single的new,single没有,只能调用object的new方法
# new方法在什么时候执行???
    # 在实例化之后,__init__之前先执行new来创建一块空间

# 单例
# 如果一个类 从头到尾只能有一个实例,说明从头到尾之开辟了一块儿属于对象的空间,那么这个类就是一个单例类
# class A:pass
# a = A()
# a2 = A()
# a3 = A()
# print(a,a2,a3)

# 单例类
# class Single:
#     __ISINCTANCE=None
#     def __new__(cls, *args, **kwargs):
#         if not cls.__ISINCTANCE:
#             cls.__ISINCTANCE=object.__new__(cls)
#         return   cls.__ISINCTANCE
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
# s1=Single(‘woi‘,12)
# s2=Single(‘ewrw‘,124)
# print(s1.name)
# print(s2.name)
# print(s1,s2)

#__str__

# class Student:
#     def __str__(self):
#         return  ‘%s %s %s‘%(self.school,self.cls,self.name)
#     def __init__(self,name,stu_cls):
#         self.school=‘oldboy‘
#         self.name=name
#         self.cls=stu_cls
# he=Student(‘nwjw‘,‘ef123‘)
# print(he)
# print(str(he))
# print(‘学生1 : %s‘%he)

# print一个对象相当于调用一个对象的__str__方法
# str(obj),相当于执行obj.__str__方法
# ‘%s‘%obj,相当于执行obj.__str__方法


# class Student:
#     def __str__(self):
#         return  ‘%s %s %s‘%(self.school,self.cls,self.name)
#     def __init__(self,name,cls,school):
#         self.school=school
#         self.name=name
#         self.cls=cls
# he=Student(‘2gou‘,‘3‘,‘wanfgcaui‘)
# print(he)
# print(str(he))
# print(‘学生1 : %s‘%he)

反射 内置方法

标签：sys   静态   input   模块   __str__   call()   str   magic   __call__   

原文地址：https://www.cnblogs.com/xdlzs/p/9394049.html