第二十七天反射和面向对像中的内置函数

1.isinstance判断类和对象之间的关系如果存在类对象关系返回True否则返回False

class Person:
    def func(self):
        pass
a=Person()
b=1
print(isinstance(a,Person)) #左边对象右边类
print(isinstance(b,Person))
结果为
True
False

2。issubclass判断是否是子类和父类之间的关系:

class Person:
    def func(self):
        pass
class Son(Person):
    pass
b=Person()
print(issubclass(Son,Person)) #左边子类右边父类(超类、基类)
结果为
True

3.反射就是用字符串形式的名字去操作变量进行操作:

  3.1我们前面也学过用字符串进行变量的操作:

name=123
print(eval(‘name‘))
结果为
123

使用这个存在安全隐患:因为这种操作是得到别人写好的代码直接执行,你也不知道别人的代码是否有代码病毒。

  3.2使用反射可以解决这一个问题,使用反射式使用一段写好的代码,然后执行里面的属性和方法。

4.反射类里面的属性

class Person:
    def func(self):
        print(‘哈哈哈‘)
a=Person()#实例化
a.name=‘alex‘#给对象中添加一个元素
Person.name=‘123‘
ret=getattr(a,‘name‘)
print(ret)
print(a.__dict__)#显示对象中所有的属性信息并以字典的形式返回
print(Person.__dict__)
结果为
alex
{‘name‘: ‘alex‘}
{‘__module__‘: ‘__main__‘, ‘func‘: <function Person.func at 0x0000024D5EFF5730>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>, ‘__doc__‘: None, ‘name‘: ‘123‘}

5.反射使用类里面的方法:

class Person:
    def func(self):
        print(‘哈哈哈‘)
a=Person()#实例化
a.name=‘alex‘#给对象中添加一个元素
ret=getattr(a,‘func‘)  #这一步得到方法的地址(和函数差不多)
ret()
结果为
哈哈哈

6那么反射有什么用:简单小例子用户通过输入想要查看某个对象的属性:

class Person:
    def func(self):
        print(‘哈哈哈‘)
a=Person()#实例化
a.name=‘alex‘#给对象中添加一个元素
a.age=16
name=input(‘输入你想查看的属性;‘)
ret=getattr(a,name)
print(ret)
结果为
输入你想查看的属性;name
alex

  还有一种方法也是可以通过字符串得到类中的属性:

class Person:
    def func(self):
        print(‘哈哈哈‘)
a=Person()#实例化
a.name=‘alex‘#给对象中添加一个元素
a.age=16
name=input(‘输入你想查看的属性;‘)
ret=a.__dict__[name]
print(ret)
结果为
输入你想查看的属性;name
alex

7但是这种方法没有办法得到类中的方法,还是只能使用反射:

class Person:
    __key=123
    @staticmethod
    def func():
        print(‘哈哈哈‘)
    @classmethod
    def func1(cls):
       return cls.__key

a=Person()#实例化
a.name=‘alex‘#给对象中添加一个元素
a.age=16
name=input(‘输入你像调用的方法;‘)
ret=getattr(Person,name)
ret()
结果为
输入你像调用的方法;func
哈哈哈

  还有一中使用反射得到方法的使用方法:

class Person:
    __key=123
    @staticmethod
    def func():
        print(‘哈哈哈‘)
    @classmethod
    def func1(cls):
       return cls.__key

a=Person()#实例化
a.name=‘alex‘#给对象中添加一个元素
a.age=16
name=input(‘输入你像调用的方法;‘)
print(getattr(Person,name)())
结果为
输入你像调用的方法;func1
123

8.模块里的反射方法:

import mile  #调用mile模块
print(getattr(mile,‘day‘))  #使用模块中day的属性
结果为
123

9.调用模块中的方法:

import mile  #调用mile模块
print(getattr(mile,‘day‘))  #使用模块中day的属性
getattr(mile,‘func‘)()  #调用模块中func方法
结果为
123
哇哈哈

10内置模块也可以使用反射方法:

import time
print((getattr(time,‘time‘))())
结果为
1582943294.4412374

11.为什么random就不能使用getattr

import random
print(getattr(random,‘randint(1,10))‘))
结果为
Traceback (most recent call last):
  File "D:/python练习程序/第二十七天/practise.py", line 48, in <module>
    print(getattr(random,‘randint(1,10))‘))
AttributeError: module ‘random‘ has no attribute ‘randint(1,10))

import  random
print(getattr(random,‘randint‘)(1,10))
结果为
6

12.那么python中是否可以反射自己的模块:

year=2020
import sys
name=input(‘请输入>>>‘)
print(getattr(sys.modules[__name__],name))

结果为
请输入>>>year
2020

13要反射函数怎么办:

import time
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))
print(getattr(time,‘strftime‘)(‘%Y-%m-%d %H:%M:%S‘))
结果为
2020-02-29 10:49:45
2020-02-29 10:49:45

14.有时候我在在使用getattr时如果没有会报错:

import time
getattr(time,‘fjdfj‘)
结果为
Traceback (most recent call last):
  File "D:/python练习程序/第二十七天/practise.py", line 55, in <module>
    getattr(time,‘fjdfj‘)
AttributeError: module ‘time‘ has no attribute ‘fjdfj‘

  怎么解决报错的问题:

import time
if hasattr(time,‘fjdfj‘): #如果为真执行下面如果为假不执行
    getattr(time,‘fjdfj‘)#两个括号里要写的一致
else:
    print(‘上面的指令有误‘)
结果为
上面的指令有误

15对类的变量进行设置修改:

class A:
    def func(self):
        print(‘修改成功‘)
a=A()
a.name=‘alex‘
print(a.name)
print(a.func())
setattr(a,‘name‘,‘subin‘) #对属性进行修改
print(a.name)
setattr(a,‘func‘,‘func1‘) #无法对方法进行修改
print(a.func1())
结果为
  File "D:/python练习程序/第二十七天/practise.py", line 69, in <module>
alex
    print(a.func1())
AttributeError: ‘A‘ object has no attribute ‘func1‘
修改成功
None
subin

class A:
    def func(self):
        print(‘修改成功‘)
a=A()
a.name=‘alex‘
print(a.name)
print(a.func())
delattr(a,‘name‘) #对属性进行修改
print(a.name)

结果为
Traceback (most recent call last):
  File "D:/python练习程序/第二十七天/practise.py", line 78, in <module>
    print(a.name)
AttributeError: ‘A‘ object has no attribute ‘name‘
alex
修改成功
None

原文地址:https://www.cnblogs.com/ab461087603/p/12381954.html

时间: 2024-11-08 03:13:10

第二十七天反射和面向对像中的内置函数的相关文章

第二十五章 面向对象------封装、内置函数、反射、动态导入

1.封装 什么是封装? 1.对外部隐藏内部的属性,以及实现细节,给外部提供使用的接口 注意:封装有隐藏的意思,但不是单纯的隐藏 学习封装的目的:就是为了能够限制外界对内部数据的访问 python中属性的权限分为两种: 1.公开的 没有任何限制,谁都可以访问 2.私有的 只有当前类本身能狗访问 默认为公共的 为什么要封装? 1.提高安全性 封装属性 2.隔离复杂度 封装方法 一个类中分为两种数据:属性和方法 封装属性 class Student: def __init__(self,name,ag

类的相关内置函数及反射

类变量的内存位置相关练习 1.1 class StarkConfig(object): list_display = [] def get_list_display(self): self.list_display.insert(0,33) return self.list_display class RoleConfig(StarkConfig): list_display = [11,22] s1 = StarkConfig() result1 = s1.get_list_display()

learn_Day14 内置函数补充、反射、初识面向对象

内置函数 __import__()用于导入模块 getattr 用于寻找模块的指定对象 a = __import__('b')  # b为模块名,b是字符串 ==>> 导入模块b并重新命名为a c = getattr(a,'d')  # d为模块中指定对象 ==>> 找到模块中命名为d的对象 d() ==>> 执行d # getattr(a,'b', c) # 从a模块中导入b.c参数可不写表示找不到报错:c为None表示找不到不报错,返回None. # hasattr

python3全栈开发-内置函数补充,反射,元类,__str__,__del__,exec,type,__call__方法

一.内置函数补充 1.isinstance(obj,cls)检查是否obj是否是类 cls 的对象 class Foo(object): pass obj = Foo() print(isinstance(obj, Foo)) #结果为True 2.issubclass(sub, super)检查sub类是否是 super 类的派生类 class Foo(object): pass class Bar(Foo): pass print(issubclass(Bar, Foo)) #结果为True

内置函数补充 之 反射

getattr 反射 为什么要有反射? 当在设计一个页面访问的时候,通过用户输入相应的url,进入相应的页面,在用户输入的url地址不存在的时候,返回404错误. def run(): inp = input('请输入要访问的url:') if inp == 'login': commons.login() elif inp == 'logout': commons.logout() elif inp == 'home': commons.home() else: print('404') ru

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

绑定,反射,内置函数

#绑定方法:绑定给谁就应该谁来调用,谁来调用就会把谁当做第一个参数自动传入 import setting #配置文件为setting class mysql: def __init__(self,host,port): #绑定到对象 self.host=host self.port=port @classmethod #绑定到类 def from_conf(cls): return cls(setting.HOST,setting.PORT) @staticmethod #不与类也不与对象绑定

python26 封装 多态 常用的内置函数 `__str__` `__del__` 反射 动态导入模块

今日内容: 1. 封装 2.多态 3. 常用的内置函数 `__str__ `__del__` 4.反射 5.动态导入模块 #1. 封装 ##1.1 什么是封装 ?(what) 对外部隐藏内部的属性,以及实现细节  , 给外部提供使用的接口 注意:封装有隐藏的意思,但不是单纯的隐藏 1.2学习封装的目的. 就是为了能够限制外界对内部数据的访问 1.3python中属性的权限分为两种 1.公开的 ?           没有任何限制 谁都能访问 2.私有的 ?          只有当前类本身能够访

绑定与非绑定方法及反射,isinstance和issubclass内置函数

目录 绑定方法与非绑定方法 1.绑定方法 2.非绑定方法(staticmethod) isinstance和issubclass 内置函数 1.isinstance 2.issubclass 反射 反射定义 4个可以实现反省的函数(内置函数) 反射使用场景 绑定方法与非绑定方法 1.绑定方法 ? 绑定方法:绑定给谁就应该由谁来调用,谁来调用就会将谁当做第一个参数传入 ? ? 绑定给对象的方法: ? 类中定义的函数默认就是绑定给对象的 ? 绑定给类的方法: ? 为类中定义的函数加上一个装饰器cla