反射 内置方法

# 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)

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

时间: 2024-09-30 05:16:55

反射 内置方法的相关文章

python基础27——反射&内置方法

反射 什么是反射? 指的是在程序运行过程中可以"动态(不见棺材不掉泪)"获取对象的信息 反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力(自省) 什么是反射机制? 反射机制指的是在程序的运行状态中 对于任意一个类,都可以知道这个类的所有属性和方法 对于任意一个对象,都能够调用他的任意方法和属性 这种动态获取程序信息以及动态调用对象的功能称为反射机制 如何实现反射? class People: def __init__(self,

面向对象之反射及内置方法

一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被类调用,就像正常调用函数一样 类方法和静态方法的相同点:都可以直接被类调用,不需要实例化 类方法和静态方法的不同点: 类方法必须有一个cls参数表示这个类,可以使用类属性 静态方法不需要参数 绑定方法:分为普通方法和类方法 普通方法:默认有一个self对象传进来,并且只能被对象调用-------绑定

day27 反射、内置方法

一.isinstance和issubclass class Foo: pass class Son(Foo): pass s = Son() #判断一个对象是不是这个类的对象,传两个参数(对象,类) # print(isinstance(s,Son)) # print(isinstance(s,Foo)) # print(type(s) is Son) # print(type(s) is Foo) #判断一个类是不是另一类的子类,传两个参数(子类,父类) print(issubclass(So

面向对象的进阶---反射--一些内置方法

反射 反射和一些类的内置方法 1 isinstance ---- issubclass type()--判断 是不是 ininstance(object,cls) 判断 是不是类的对象 如果这个类有父类 这个对象也是这个父类的对象 issubclaaa(cls,cls) 判断一个类是不是另一个类的子类 ============================= 反射 ================================= 把一个字符串 类型的变量 变成一个 真实存在这个程序中的变量名

python全栈开发【第十七篇】面向对象反射和内置方法

一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被类调用,就像正常调用函数一样 类方法和静态方法的相同点:都可以直接被类调用,不需要实例化 类方法和静态方法的不同点: 类方法必须有一个cls参数表示这个类,可以使用类属性 静态方法不需要参数 绑定方法:分为普通方法和类方法 普通方法:默认有一个self对象传进来,并且只能被对象调用-------绑定

面向对象:反射、内置方法

反射:通过字符串映射到对象或者类的属性 反射的方法: class People: country = "China" def __init__(self,name,age): self.name = name self.age = age def talk(self): print("%s is talking" % self.name) obj = People("neo",22) """ 判断是否拥有某个属性:

反射、自定义内置方法来定制类的功能、元类

一.反射 1. 定义:通过字符串来操作类或者对象属性 2. 方法:hasattr.getattr.setattr.delattr 3. 使用方法: 1 class People: 2 def __init__(self,name): 3 self.name=name 4 def put(self): 5 print('%s is putting'%self.name) 6 def get(self): 7 print('%s get sth'%self.name) 8 def run(self)

1、面向对象内置函数 2、反射 3、内置方法

1.isinstance()    判断对象所属类型,包括继承关系 2.issubclass() 判断类与类之间的继承关系 class A:pass class B(A): pass print(isinstance(b,B))   # o,t print(isinstance(b,A))  #  o,t class mystr(str): pass ms = mystr("alex") print(type(ms) is str)  # 不包含继承关系,只管一层 print(isin

面向对象进阶:反射以及内置方法

一.反射 反射:使用字符串数据类型的变量名来获取这个变量的值 input:用户输入的如果是a,那么打印1.如果输入的是b那么就打印2.如果输入name,那么打印alex 文件:从文件中读出的字符串,想转换成变量的名字 网络:将网络传输的字符串转换成变量的名字 1.反射类中的变量:静态属性,类方法 # class Foo: # School = 'oldboy' # Country = 'China' # language = 'Chinese' # @classmethod # def clas