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

 getattr(pyMethod(),'out%s'%str)()  注意pyMethod()和最后的()   这里之所以这么写pyMethod()加括号是实例化类对象,最后的括号,因为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 能够为变量。

365bet体育在线直播 ,返回 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()

bet36体育在线投注 ,总结

以上就是这篇作品的全部内容了,希望本文的剧情对大家的求学可能工作能推动一定的帮忙,要是有问号我们能够留言沟通,谢谢大家对帮客之家的支撑。

bet36体育 ,参考

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()函数才叫反射,通过字符串的样式在模块中追寻对应的要素,假使元素不存在,则报错.

  • 能够经过给getattr(module,arrtib,def)设置私下认可值,幸免报错

  • 反射函数

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

  • 扩展

    • 通过__import__()导入的模块假若存在的路子为:lib\modules\moudle.py
    • 假诺导入的点子为:__import__(‘lib.modules.moudle’),则导入的为lib文件夹
    • 如果想化解那么些标题,导入的艺术为:__import__(‘lib.modules.moudle’,
      fromlist=True)

参考资料:

不前进,不倒退,结束的情况是未曾的.

据书上说反射模拟web框架路由系统

  • 依据用户发送不一致的url,服务器执行分化的操作,再次来到分歧的结果
  • 土生土长操作:
    1. 截取url最终的字段,如login,logout,pay等
    2. 由此if,elif,else判断字段,然后实施模块里面包车型地铁章程
  • 优化:
    1. 1旦网址极大,有许四个主意,都要if,elif,else来判断,则必要写大批量的判断代码
    2. 透过反射来赢得相应的诀窍,然后调用,则足以不要修改index.py方法,只需求在模块里面添加响应的措施,让url中的字段去相称
  • 完善:
    1. 可是只要网址太大了,全体的法子都写在3个模块里面,维护起来会很费力,同时反射获取方式须要更加长的日子
    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本质都是以此道理

德姆o:一个模块帮助html、text、xml等格式的打字与印刷,依据传入的formate参数的两样,调用分化的函数落成二种格式的出口

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

面向对象

  • 编制程序语言:

    • 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,那样方法的参数重复且调用的时候很麻烦,假如把它们都卷入到目的里,直接在目的里调用,那样重复的参数只要求穿二次即可.
      • 卷入步骤

        • 上面包车型大巴包裹进程不够好,因为1旦人家看您的代码,外人不自然领会调用方法前须要封装数据,能够优化为:
        • 创设对象时会调用构造方法__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都有1样的不2秘诀,则以延续时写在左手的为主,要是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
        • 作业级别:访问后台的地址

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动态去调用。

用getattr完成工厂方法:

举个栗子:

Python找那一个的getattr()函数详解

发表评论

电子邮件地址不会被公开。 必填项已用*标注