getattr()那些法子最要害的功能是促成反射机制。相当于说能够通过字符串获取方式实例。  传入分裂的字符串,调用的法子不平等。

Python中用字符串调用函数或格局言传身教代码,python示例代码

前言

正文主要给咱们介绍了关于Python用字符串调用函数或情势的相关内容,分享出来供大家参考学习,下边来一同看看详细的牵线:

先看贰个例证:

>>> def foo():
    print "foo"

>>> def bar():
    print "bar"

>>> func_list = ["foo","bar"]
>>> for func in func_list:
    func()
TypeError: 'str' object is not callable

大家盼望遍历执行列表中的函数,不过从列表中拿走的函数名是字符串,所以会提醒类型错误,字符串对象是不得以调用的。若是大家想要字符串变成可调用的对象呢?或是想经过变量调用模块的习性和类的习性呢?

以下有三种办法能够兑现。

eval()

>>> for func in func_list:
    eval(func)()
foo
bar

eval()
平常用来执行一个字符串表达式,并回到表明式的值。在此间它将字符串转换来对应的函数。eval()
效用强大不过相比较危险(eval is evil),不提议选用。

locals()和globals()

>>> for func in func_list:
    locals()[func]()
foo
bar

>>> for func in func_list:
    globals()[func]()
foo
bar

locals() 和 globals()
是python的三个放置函数,通过它们得以一字典的办法访问片段和全局变量。

getattr()

getattr() 是 python 的内建函数,getattr(object,name) 就相当于object.name,可是那里 name 能够为变量。

返回 foo 模块的 bar 方法

>>> import foo
>>> getattr(foo, 'bar')() 

回去 Foo 类的属性

>>> class Foo:
  def do_foo(self):
    ...

  def do_bar(self):
    ...

>>> f = getattr(foo_instance, 'do_' + opname)
>>> f()

总结

上述便是那篇小说的全体内容了,希望本文的内容对大家的求学或然办事能拉动一定的帮助,假诺有问号我们能够留言沟通,多谢大家对帮客之家的支撑。

参考

Calling a function of a module from a string with the function’s name in
Python

How do I use strings to call functions/methods?

前言
本文首要给大家介绍了有关Python用字符串调用函数或方法的连锁内容,分享…

反射

  • 反射:
    1. 因而字符串的花样导入模块
    2. 经过字符串的样式去模块中寻找制定的成员(属性、函数),并使用

# 1.创建index.py主程序
# 2.创建commoms模块提供函数
# 3.引入commons模块调用模块中的函数

# commoms.py
def f1():
    print('F1')
    return 'F1'

# index.py
import commons
if __name__ == '__main__':
    ret = commons.f1()
    print(ret) # F1
  • 地点的函数是健康导入并履行,假如想导入用户输入的模块名,并调用用户输入的函数,则:

# index.py
if __name__ == '__main__':
    module = input('请输入模块名:')
    mod = __import__(module)
    # ret = mod.f1() # 正常调用
    # print(ret) # 正常输出
    attr = input('请输入方法名:')
    meth = getattr(mod,attr)
    ret = meth()
    print(ret)
  • 地方的函数也正是调用了二个函数

    • __import__():通过字符串导入模块对象
    • getattr(module,attr):获取模块里的要素
  • 实在getattr()函数才叫反射,通过字符串的方式在模块中找寻对应的因素,即使成分不存在,则报错.

  • 金沙注册送58 ,能够通过给getattr(module,arrtib,def)设置默许值,幸免报错

  • 反射函数

    • getattr():获取属性
    • delattr():删除属性
    • hasattr():判断进行是不是留存
    • setattr():添加或修改属性
  • python中,一切皆对象,通过反射,依据字符串去对象中(模块,类)获取成分

  • 扩展

    • 通过__import__()导入的模块假设存在的门路为:lib\modules\内建函数getattr工厂形式,面向对象。moudle.py
    • 假如导入的主意为:__import__(‘lib.modules.moudle’),则导入的为lib文件夹
    • 若果想缓解这几个标题,导入的方法为:__import__(‘lib.modules.moudle’,
      fromlist=True)

标题聚焦:

原型:getattr(对象,方法名)

根据反射模拟web框架路由系统

  • 据他们说用户发送分裂的url,服务器执行分化的操作,重回不一致的结果
  • 原始操作:
    1. 截取url最终的字段,如login,logout,pay等
    2. 通过if,elif,else判断字段,然后实施模块里面包车型客车措施
  • 优化:
    1. 设若网站十分的大,有为数不少个点子,都要if,elif,else来判定,则需求写大量的判定代码
    2. 因而反射来取得相应的章程,然后调用,则足以绝不修改index.py方法,只必要在模块里面添加响应的不二法门,让url中的字段去匹配
  • 完善:
    1. 然则如若网站太大了,全体的主意都写在叁个模块里面,维护起来会很辛劳,同时反射获取格局须要更长的大运
    2. 通过分模块来管理不一样功效的法子,在url中把模块和格局名都加上,切割后通过__import__(path,
      fromlist = True)来导入模块,通过反射获取形式

# 1.创建主程序index.py
# 2.创建功能模块
# 3.截取url,获取里面的地址参数执行不同的方法

# url = input("请输入url:")
url = 'www.yuhhcompany.com/account/login'
regex = 'www.yuhhcompany.com'
ret = re.match(regex, url)
if ret != None:
    # 匹配成功
    host, module, method = url.split('/')
    mod = __import__(module, fromlist=True)
    if hasattr(mod, method):
        ret = getattr(mod, method)()
  • 所有的web框架:php,c#,java,Django本质都以其一道理

熟习getattr的应该精通,getattr(a, ‘b’)的意义就和a.b是一致的

那正是说那一个内建函数有怎么着效益呢,最有利的实实在在是应用它来贯彻工厂方法(Factory
Method)格局

此外,在回调函数里也时不时应用那几个函数,对回调明白不深,那里不再举例

 

面向对象

  • 编制程序语言:

    • java、c#只好由此面向对象编制程序
    • Python能够经过函数式编制程序,也足以透过面向对象编制程序
  • Python面向对象:

    • class:创立类首要字
    • 概念的函数,在函数式编制程序时称函数,面向对象编制程序称为方法
    • 办法参数self:种种方法都急需丰硕self参数,值为调用该方法的靶子,点用方法时python会自动传入该参数,不供给团结传

    class Cat:
        def fun1(self):
            pass
        def fun2(self):
            pass
    
    cat1 = Cat()
    cat1.fun1()
    cat1.fun2()
    
  • 格局的参数self:

    • self代表调用方法的靶子,不供给协调传入,当调用方法时,python自动帮大家传入该self参数

    class Cat:
        def fun1(self):
            print(self)
    cat1 = Cat()
    print(cat1) # <__main__.Cat object at 0x10073fc50>
    cat1.fun1() # <__main__.Cat object at 0x10073fc50>
    
    • 封装:

      • 万一三个类中四个措施须求用到同二个参数,每一遍都穿的话,太费力

      class Cat:
          def fun1(self, name, age):
              print(name, age)
          def fun2(self, name, age):
              print(name, age)
          def fun3(self, name, age):
              print(name, age)
      
      cat1 = Cat()
      cat1.fun1('yhh', 23)
      cat1.fun2('yhh', 23)
      cat1.fun3('yhh', 23)
      
      • 能够将重新的变量作为对象的品质:
        • 把参数赋值给指标,在格局中调用–封装

      class Cat:
          def fun1(self):
              print(self.name, self.age)
          def fun2(self):
              print(self.name, self.age)
          def fun3(self):
              print(self.name, self.age)
      
      cat1 = Cat()
      cat1.name = 'yhh'
      cat1.age = 23
      cat1.fun1()
      cat1.fun2()
      cat1.fun3()
      
      • 卷入使用情状:

        • 三番五次操作数据库,对数据库的操作(curd)都亟需用到ip,port,user,password,content等,假诺各种方法都传ip,port,user,passowrd,那样方法的参数重复且调用的时候很麻烦,就算把它们都打包到对象里,直接在目的里调用,那样重复的参数只须求穿一次即可.
      • 卷入步骤

        • 地点的卷入进程不够好,因为一旦别人看你的代码,外人不自然知道调用方法前需求封装数据,能够优化为:
        • 创制对象时会调用构造方法__init__(),对象销毁的时候会调用__del__()方法(析构方法)

      class Cat:
          def __init__(self, name, age):
              self.name = name
              self.age = age
          def fun1(self):
              print(self.name, self.age)
          def fun2(self):
              print(self.name, self.age)
          def fun3(self):
              print(self.name, self.age)
      
    • 指标体系化

      • 在python中,对象足以经过pickle连串化,然后在该地持久化,可以用来存档
      • 无法用json,因为json只好转成python的主干项目,自定义类不属于基本类型

      import pickle
      
      # 存档
      with open('object.pickle', mode='wb') as file:
          pickle.dump(cat1,file)
      
      # 读档
      with open('object.pickle', mode='rb') as file:
          cat1 = pickle.load(file)
          cat1.fun1() # YHH 23
      
    • 继承

      • python中继承是急需在子类的类名后跟上:(父类类名)
      • 父类–子类
      • 基类–派生类
      • 派生类和父类有同一的措施时,以派生类为主

      class Father:
          def fun1(self):
              print('Father')
      
      class Son(Father):
          def fun2(self):
              print('Son')
      
      son = Son()
      son.fun1()  # Father
      son.fun2()  # Son
      
    • 多继承

      • java、c#只匡助单继承
      • python能够多再三再四
      • 设若A继承B和C,B和C都有一样的法门,则以一连时写在左侧的为主,若是A也有那一个艺术,则以A为主
    • 多继承面试题:

    在pytho3.5中:
    # 如果继承关系
    class E(C,D):
        pass
    # A --> C --> E
    # B --> D --> E
    # E继承CD,C继承A,D即成B
    # 则调用的顺序为:E --> C --> A --> D --> B(顶层没有同一个基类)
    
    # 如果A和B同时又继承BASE基类,则调用顺序为:
    E --> C --> A --> D --> B --> BASE(顶层有同一个基类)
    python2.7不一样
    
    • 多态

      • python本身语言特色就协理多态,像java,c#等因为是强类型语言,相比较复杂

      lass Cat():
          def fun1(self):
              print('fun1')
      
      class Dog():
          def fun1(self):
              print('fun1')
      
      def function(animal):
          animal.fun1()
      
      function(Cat())
      function(Dog())
      
      • 任何语言有重载,python不支持
    • 接口

      • python语言没有接口一说
      • 接口类型:
        • 代码级别:interface
        • 政工级别:访问后台的地方

先看一下合法文书档案:

举个栗子:

getattr(object, name[, default])

pyMethod类下定义了八个章程,getattr(pyMethod(),’out%s’%str)()  
传入的主意名不一样,调用不一样的法门。些处方法名为字符串。

Return the value of the named attribute of object. name must be a
string. If the string is the name of one of the object’s attributes, the
result is the value of that attribute. For example, getattr(x, ‘foobar’)
is equivalent to x.foobar. If the named attribute does not exist,
defaultis returned if provided, otherwise AttributeError is raised.

那样的话,想想是或不是用途很多,小编能够把措施名配置到文件中,读取时使用getattr动态去调用。

参数表明:

#coding=utf-8

class pyMethod(object):
    def outstr(self):
        print('this is string')

    def outint(self):
        print('this is number')

    def outdate(self):
        print('this is date')


if __name__=="__main__":
    str = 'int'
    getattr(pyMethod(),'out%s'%str)()     
    str = 'str'
    getattr(pyMethod(),'out%s'%str)()
    str = 'date'
    getattr(pyMethod(),'out%s'%str)()

 

try:
    func = getattr(obj, "method")
except AttributeError:
    ...... deal
else:
    result = func(args)

// 或指定默认返回值
func = getattr(obj, "method", None)
if func:
    func(args)
 getattr(pyMethod(),'out%s'%str)()  注意pyMethod()和最后的()   这里之所以这么写pyMethod()加括号是实例化类对象,最后的括号,因为getattr函数反射后,是一个方法对象。

TypeError: 不可调用

 

func = getattr(obj, "method", None)
if callable(func):
    func(args)

运营结果:

用getattr达成工厂方法:

C:\Python27\python.exe D:/weixin/python_getattr.py
this is number
this is string
this is date

Process finished with exit code 0

德姆o:二个模块扶助html、text、xml等格式的打字与印刷,依照传入的formate参数的分歧,调用差异的函数达成两种格式的出口

 

import statsout 
def output(data, format="text"):                           
    output_function = getattr(statsout, "output_%s" %format) 
    return output_function(data)

Linux and
python学习交换1,2群已满.

以此事例中能够根据传入output函数的format参数的例外
去调用statsout模块差别的点子(用格式化字符串完毕output_%s)

Linux and
python学习调换3群新开,欢迎插手,一起学习.qq 3群:563227894

参考资料:

不前进,不倒退,结束的情景是一贯不的.

Python找那么些的getattr()函数详解

共同发展,与君共勉,

python2.7文档

纯熟getattr的应有精晓,getattr(a,
‘b’)的坚守就和a.b是一模一样的
那么那几个内建函数有如何效果吗,最有利于的实地是采用它来贯彻工厂…

相关文章

网站地图xml地图