新金沙3777

面向对象,传入的方法名不同

十一月 7th, 2019  |  未分类

 

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

新金沙3777,小编们意在遍历试行列表中的函数,不过从列表中拿走的函数名是字符串,所以会唤起类型错误,字符串对象是不得以调用的。假若大家想要字符串产生可调用的对象啊?或是想通过变量调用模块的习性和类的习性呢?

以下有两种方法能够兑现。

十大正规网赌网址,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用字符串调用函数或格局的相干内容,分享…

基于反射模拟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本质都以其风度翩翩道理

 

面向对象

  • 编制程序语言:

    • 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
        • 事务品级:访谈后台的地点

运作结果:

反射

  • 反射:
    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)
  • 地点的函数也就是调用了2个函数

    • __import__():通过字符串导入模块对象
    • getattr(module,attr):获取模块里的要素
  • 事实上getattr()函数才叫反射,通过字符串的样式在模块中搜寻对应的成分,若是成分空头支票,则报错.

  • 能够经过给getattr(module,arrtib,def)设置暗许值,制止报错

  • 反射函数

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

  • 扩展

    • 通过__import__()导入的模块如若存在的路子为:libmodulesmoudle.py
    • 假如导入的章程为:__import__(‘lib.modules.moudle’),则导入的为lib文件夹
    • 风姿罗曼蒂克旦想缓和这些主题材料,导入的法子为:__import__(‘lib.modules.moudle’,
      fromlist=True)

不前行,不倒退,截至的情状是从未的.

C:Python27python.exe D:/weixin/python_getattr.py
this is number
this is string
this is date

Process finished with exit code 0

getattr()那一个方法最重要的作用是实现反射机制。也正是说可以透过字符串获取方式实例。  传入不一样的字符串,调用的法子不等同。

Linux and
python学习沟通1,2群已满.

 

 

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

同步前进,与君共勉,

 getattr(pyMethod(),'out%s'%str)()  注意pyMethod()和最后的()   这里之所以这么写pyMethod()加括号是实例化类对象,最后的括号,因为getattr函数反射后,是一个方法对象。

pyMethod类下定义了多个办法,getattr(pyMethod(),’out%s’%str)()  
传入的法子名分裂,调用区别的法子。些处方法名称叫字符串。

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

这样的话,动脑筋是还是不是用场超多,小编得以把办法名配置到文件中,读取时选用getattr动态去调用。

举个栗子:

Linux and
python学习调换3群新开,接待参与,一起学习.qq 3群:563227894

相关文章

Your Comments

近期评论

    分类目录

    • 没有分类目录

    功能


    网站地图xml地图