精华内容
下载资源
问答
  • python动态调用函数

    千次阅读 2018-04-03 10:42:08
    会java的开发人员都知道java中动态调用一个类中的方法都是使用反射机制,动态加载class(包名+类名+'.class')获取类对象,然后再获取method,再调用对应方法等但是python中在一个py文件中,不通过from...import来引入...

    会java的开发人员都知道java中动态调用一个类中的方法都是使用反射机制,动态加载class(包名+类名+'.class')获取类对象,然后再获取method,再调用对应方法等

    但是python中在一个py文件中,不通过from...import来引入另一个py,然后调用其中的函数呢?

    废话不多说,直接上代码:

    文件目录为:

    mytest1.py:

    class Test1:
        def test1(self, name):
            print("this is my_test1.py class Test1 func is test1 args is %s" % name)
        def test2(self, name):
            print("this is my_test2.py class Test1 func is test2 args is %s" % name)
    
    def test2(name):
        print("this is my_test1.py func is test2 args is %s" % name)

    我想在test_main.py中调用my_test1.py中的test2方法,并传递name参数

    test_main.py

    #使用__import__
    
    ip_module = __import__('my_test1')
    print(dir(ip_module))#查看my_test1中有哪些属性、类、函数
    #调用引入py文件中的类中的函数
    test2_func = getattr(ip_module, "test2")#获取test2函数
    test2_func('test2_name')#调用并传递参数
    ['__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'test2']
    this is my_test1.py func is test2 args is test2_name

    这样就可以调用啦

    但是,如果我在my_test1.py中Test1类中的test1()方法呢?如下:

    ip_module = __import__('my_test1')
    test1_class = getattr(ip_module, "Test1")
    test1_obj = test1_class()
    test1_func = getattr(test1_obj, 'test1')
    test1_func("test1_name")

    运行结果:

    this is my_test1.py class Test1 func is test1 args is test1_name

    当然,我也可以循环遍历Test1下的所有方法:

    for attr in dir(test1_obj):
        if attr[0] != '_':
            class_attr_obj = getattr(test1_obj, attr)
    
            if hasattr(class_attr_obj, '__call__'):
                class_attr_obj('aa')
            else:
                print(attr, ' type:', type(class_attr_obj), ' value:', class_attr_obj)

    这样会把Test1下的所有方法都调用一遍

    this is my_test1.py class Test1 func is test1 args is aa
    this is my_test2.py class Test1 func is test2 args is aa

    另外还可以用另一种方式,需要依赖  importlib

    import importlib
    my_test1_module = importlib.import_module('my_test1', ".")
    
    my_test1_func_test2 = getattr(my_test1_module,"test2")
    my_test1_func_test2("my_test1_func_test2")#调用my_test1中的test2方法  非Test1类中的
    
    my_test1_cls = getattr(my_test1_module, "Test1")
    cls_obj = my_test1_cls()
    my_test1_test1 = getattr(cls_obj, 'test1')
    my_test1_test1('my_test1_test1')#调用Test1中的test1方法
    
    my_test1_test2 = getattr(cls_obj, 'test2')
    my_test1_test2('my_test1_test2')#调用Test1中的test2方法

    运行:

    this is my_test1.py func is test2 args is my_test1_func_test2
    this is my_test1.py class Test1 func is test1 args is my_test1_test1

    this is my_test2.py class Test1 func is test2 args is my_test1_test2


    如果我在test_1包下创建了my_test2.py,代码如下:

    class Test2:
        def test1(self, name):
            print("this is test_1.my_test2.py class Test2 func is test1 args is %s" % name)
        def test2(self, name):
            print("this is test_1.my_test2.py class Test2 func is test2 args is %s" % name)
    
    def test2(name):
        print("this is test_1.my_test2.py func is test2 args is %s" % name)

    那么,我想在test_main.py下调用my_test2该如何调用呢?

    其实很简单,只需要加载的时候加上包名就可以了

    import importlib
    my_test1_module = importlib.import_module('test_1.my_test2', ".")
    
    my_test1_func_test2 = getattr(my_test1_module,"test2")
    my_test1_func_test2("my_test1_func_test2")#调用my_test1中的test2方法  非Test1类中的
    
    my_test1_cls = getattr(my_test1_module, "Test2")
    cls_obj = my_test1_cls()
    my_test1_test1 = getattr(cls_obj, 'test1')
    my_test1_test1('my_test1_test1')#调用Test1中的test1方法
    
    my_test1_test2 = getattr(cls_obj, 'test2')
    my_test1_test2('my_test1_test2')#调用Test1中的test2方法

    结果如下:

    this is test_1.my_test2.py func is test2 args is my_test1_func_test2
    this is test_1.my_test2.py class Test2 func is test1 args is my_test1_test1
    this is test_1.my_test2.py class Test2 func is test2 args is my_test1_test2

    以上代码均都经过自己测试运行,如果有问题请留言。大家一起学习,一起进步

    展开全文
  • python 动态调用函数

    2017-11-14 17:30:00
    1. 根据字符串名称 动态调用 python文件内的方法eval("function_name")(参数) 2. 根据字符串 动态调用类中的静态方法,getattr(ClassName,"function_name")(参数) 3. apply(functoin_name,parameters) 这个...

    1. 根据字符串名称 动态调用 python文件内的方法eval("function_name")(参数)

    2. 根据字符串 动态调用类中的静态方法,getattr(ClassName,"function_name")(参数)

    3. apply(functoin_name,parameters)  这个function_name不是字符串,而是函数对象本身;parameters是参数,类似(a,b,...)这样的格式

    4. 当函数不确定参数的数目时候,采用 一个 * 或两个** 他们的用法是有讲究的。http://blog.csdn.net/feisan/article/details/1729905

    下面的例子是,定义了一个函数列表字典,字典中保存有函数对象和函数的参数,可以实现动态为字典添加执行的函数,最后一起执行

    from collections import OrderedDict
    
    class ComponentCheck:
        def __init__(self, data_dir):
            self.data_dir = data_dir
    
            self._extend_function_dic = OrderedDict({})
    
        def add_extend_function(self, function_name, *parameters):
            self._extend_function_dic[function_name] = parameters
    
        def _check_extend_function(self):
            for function_name, parameters in self._extend_function_dic.iteritems():
                if not apply(function_name, parameters):
                    return False
            return True
    
    class CheckFunctions:
        def __init__(self):
            pass
    
        def tollcost_check(data_path):
            toll_cost_path = os.path.join(data_path, Importer.DT_KOR_TOLL_COST)
            tollcost_component = ComponentCheck(toll_cost_path)
            tollcost_component.add_extend_function(tollcost_component.check_file_pattern_list_match, CheckFunctions.TOLL_COST_FILENAME_PATTERN)
            return tollcost_component
    @staticmethod
        def speed_camera_check(data_path):
            speed_camera_path = os.path.join(data_path, Importer.DT_SAFETY_CAMERA)
            speed_camera_component = ComponentCheck(speed_camera_path)
            speed_camera_component.add_extend_function(speed_camera_component.check_not_exist_empty_directory)
            return speed_camera_component
    

      

    转载于:https://www.cnblogs.com/dasheng-maritime/p/7833658.html

    展开全文
  • 主要介绍了python 动态调用函数实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python动态调用函数

    2019-04-26 15:33:39
    Python动态调用函数 在Java中,动态调用可通过反射机制实现。Python中,也可通过__import__(filename) + getattr()实现。 1、__import__(filename):动态加载 python中,一般通过from XX import XX引入模块,...

                                         Python之动态调用函数

         在Java中,动态调用可通过反射机制实现。Python中,也可通过__import__(filename) + getattr()实现。

    1、__import__(filename):动态加载

    python中,一般通过from XX import XX引入模块,当调用模块不确定时,可通过__import__()动态载入,通过“字符串”函数名动态调用函数。

    def __import__(name, globals=None, locals=None, fromlist=(), level=0): # real signature unknown; restored from __doc__
        """
        __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
        
        Import a module. Because this function is meant for use by the Python
        interpreter and not for general use it is better to use
        importlib.import_module() to programmatically import a module.
        
        The globals argument is only used to determine the context;
        they are not modified.  The locals argument is unused.  The fromlist
        should be a list of names to emulate ``from name import ...'', or an
        empty list to emulate ``import name''.
        When importing a module from a package, note that __import__('A.B', ...)
        returns package A when fromlist is empty, but its submodule B when
        fromlist is not empty.  Level is used to determine whether to perform 
        absolute or relative imports. 0 is absolute while a positive number
        is the number of parent directories to search relative to the current module.
        """
        pass

    name: 模块名

     

    2、getattr() :返回一个对象属性值

    def getattr(object, name, default=None): # known special case of getattr
        """
        getattr(object, name[, default]) -> value
        
        Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
        When a default argument is given, it is returned when the attribute doesn't
        exist; without it, an exception is raised in that case.
        """
        pass

    object:对象属性的值

    name:  类属性名对应的字符串

    default: name对应属性不存在,给定default参数则返回default,没有default,则直接有AttributeError异常

     

    3、例子

    动态引入运行:#1 动态载入模块 ;#2 获取类对象; #3 获取函数对象,func(para_comm) 动态调用函数。

    注:

    载入模块时,会碰见"No module named XXX" ,  注意path搜索模块路径的配置。

    获取对象时,也可通过  hasattr(calssname, attributename) 判断属性是否存在, 避免AttributeError的异常。

    import_module = __import__(moudlename)   # 1
    b = getattr(import_module, classname)() # 2
    func = getattr(b, methodname)          # 3
    res = func(para_comm)   # para_comm 传入参数

     

     

     

    展开全文
  • Python3 根据函数名动态调用函数

    千次阅读 2019-07-02 21:18:48
    最近项目需求,需要动态调用函数,这里整理一下思路。 很多时候,我们需要根据外面传进来的字符串取动态调用函数,并获取返回值。例如单项目检查等,检查的类型可以事先在定义文件中配置好,这样后期维护的时候,...

    最近项目需求,需要动态调用函数,这里整理一下思路。

    很多时候,我们需要根据外面传进来的字符串取动态调用函数,并获取返回值。例如单项目检查等,检查的类型可以事先在定义文件中配置好,这样后期维护的时候,如果需要修改,直接修改配置文件就好了,而不必修改代码。要动态调用,如果是在同一个模块(.py)中,直接使用eval(function_name)(param(如果有的话))。如果是在一个模块中动态调用另一个模块中的函数,则需要使用 importlib 包。这里主要介绍 eval 用法, importlib 包的具体用法后面再做追加。

    事先定义多个方法:

    # 检查文本类型是否为字符串
    # @param text 文本
    # @return True:是,False:不是
    def __string(text):
        return True if isinstance(text, str) else False
    
    
    # 检查文本类型是否为浮点型
    # @param text 文本
    # @return True:是,False:不是
    def __float(text):
        if __string(text):
            try:
                return True if float("{0}".format(text)) else False
            except Exception:
                return False
        else:
            return True if isinstance(text, float) else False
    
    
    # 检查文本类型是否为浮点型
    # @param text 文本
    # @return True:是,False:不是
    def __int(text):
        if __string(text):
            try:
                return True if float("{0}".format(text)) else False
            except Exception:
                return False
        else:
            return True if isinstance(text, float) else False
    
    
    # 检查文本类型是否为数字型
    # @param text 文本
    # @return True:是,False:不是
    def __number(text):
        return True if re.search("[^0-9]", text) == None else False

    然后再写一个函数来可以动态的调用这些函数(根据函数名字符串):

    # 项目check
    # @param tag 标签名
    # @param text 文本
    # @return True:OK, False:NG
    def item_check(func_name, text):
        if type and text:
            try:
                # 调用导入模块中的函数,并传参
                return eval("__{0}".format(func_name))(text)
            except Exception:
                return False
        else:
            return False

    现在,我们来测试一下这样的方法是否正确可用:

    result = item_check("number", "123456")
        print("{0}是否为{1}:{2}".format("123456", "number", result))

    运行程序,控制台输出:

    123456是否为number:True

    Process finished with exit code 0

    说明我们的动态调用是OK的。

    下面是完整的代码:

    文件:item_check.py

    import re
    
    
    # 检查文本类型是否为字符串
    # @param text 文本
    # @return True:是,False:不是
    def __string(text):
        return True if isinstance(text, str) else False
    
    
    # 检查文本类型是否为浮点型
    # @param text 文本
    # @return True:是,False:不是
    def __float(text):
        if __string(text):
            try:
                return True if float("{0}".format(text)) else False
            except Exception:
                return False
        else:
            return True if isinstance(text, float) else False
    
    
    # 检查文本类型是否为浮点型
    # @param text 文本
    # @return True:是,False:不是
    def __int(text):
        if __string(text):
            try:
                return True if float("{0}".format(text)) else False
            except Exception:
                return False
        else:
            return True if isinstance(text, float) else False
    
    
    # 检查文本类型是否为数字型
    # @param text 文本
    # @return True:是,False:不是
    def __number(text):
        return True if re.search("[^0-9]", text) == None else False
    
    
    # 项目check
    # @param tag 标签名
    # @param text 文本
    # @return True:OK, False:NG
    def item_check(func_name, text):
        if type and text:
            try:
                # 调用导入模块中的函数,并传参
                return eval("__{0}".format(func_name))(text)
            except Exception:
                return False
        else:
            return False
    
    
    if __name__ == "__main__":
        result = item_check("number", "123456")
        print("{0}是否为{1}:{2}".format("123456", "number", result))

     

    展开全文
  • python 动态调用模块内的函数

    千次阅读 2017-09-08 11:19:30
    同一个路径利用 getattr 动态调用函数:main.py 与 third_buy.py在同一个路径下# third_buy中有N个***_func(params)函数 import third_buythird_method = '%s_func' % method # 通过函数名的字符串来调用这个函数 ...
  • python动态调用类和函数的方法

    千次阅读 2019-03-22 11:43:25
    from utils.parameter_model import ParameterModel from utils.cluster_model import ClusterModel from utils.server_model import ServerModel parameter_model = ParameterModel() cluster_model = ClusterMod....
  • 内置的4个函数可以搞定 eval() for func in func_list: eval(func)() locals()和globals() >>> for func in func_list: locals()[func]() >>> for func in func_list: globals(...
  • list = inspect.getmembers(GetFreeProxy, predicate=inspect.isfunction) out : [('jiangxianli', ), ('kuaidaili', )] 返回值说明 [ (函数名称,函数地址) ] 函数地址可以直接添加括号"()"运行,获取返回值 动态历遍...
  • 利用python中的内置函数eval(),函数说明: def eval(*args, **kwargs): # real signature unknown """ Evaluate the given source in the context of globals and locals. The source may be a string repre...
  • Python动态执行函数

    千次阅读 2018-08-22 18:34:09
    根据函数名,来调用执行函数  
  • 部门小伙伴遇到一个样本需要对动态函数调用就行批量注释还原的问题,通过idapython可以大大的减少工作量,其实这一问题也是很多样本分析中最耗时间的一块,下面来看看如何解决这个问题(好吧这才是今年最后一篇技术...
  • Python调用C语言函数

    2015-03-23 21:53:56
    为什么我们需要这样做呢,因为有些时候,我们可能需要一个性能上比较讲究的算法,有些时候,我们可以在Python中使用已经有了的现成的被封闭在动态链接库中的函数。下面是如何调用的示例。 首先,我们用一个乘法来
  • 环境 win10 (64位) vs2017 python3.6(64位) vs2017需要安装组件如下图: 如果你想要在windows上使用mingw来编译生成DLL的话...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,216
精华内容 486
关键字:

python动态调用函数

python 订阅