Chamar uma função de um módulo usando seu nome (uma string)
Pergunta
Qual é a melhor maneira de chamar uma função dada uma string com o nome da função em um programa Python.Por exemplo, digamos que eu tenha um módulo foo
, e eu tenho uma string cujo conteúdo é "bar"
.Qual é a melhor forma de ligar foo.bar()
?
Preciso obter o valor de retorno da função, e é por isso que não uso apenas eval
.Eu descobri como fazer isso usando eval
para definir uma função temporária que retorne o resultado dessa chamada de função, mas espero que haja uma maneira mais elegante de fazer isso.
Solução
Assumindo módulo foo
com método bar
:
import foo
method_to_call = getattr(foo, 'bar')
result = method_to_call()
No que diz respeito a isso, as linhas 2 e 3 podem ser compactadas para:
result = getattr(foo, 'bar')()
se isso faz mais sentido para o seu caso de uso.Você pode usar getattr
desta forma em métodos vinculados a instâncias de classe, métodos em nível de módulo, métodos de classe...A lista continua.
Outras dicas
locals()["myfunction"]()
ou
globals()["myfunction"]()
moradores locais retorna um dicionário com uma tabela de símbolos locais atual. globais retorna um dicionário com tabela de símbolos globais.
A solução de Patrick é provavelmente a mais limpa.Se você também precisar selecionar o módulo dinamicamente, poderá importá-lo como:
module = __import__('foo')
func = getattr(module, 'bar')
func()
Apenas uma simples contribuição.Se a classe que precisamos instanciar estiver no mesmo arquivo, podemos usar algo assim:
# Get class from globals and create an instance
m = globals()['our_class']()
# Get the function (from the instance) that we need to call
func = getattr(m, 'function_name')
# Call it
func()
Por exemplo:
class A:
def __init__(self):
pass
def sampleFunc(self, arg):
print('you called sampleFunc({})'.format(arg))
m = globals()['A']()
func = getattr(m, 'sampleFunc')
func('sample arg')
# Sample, all on one line
getattr(globals()['A'](), 'sampleFunc')('sample arg')
E, se não for uma aula:
def sampleFunc(arg):
print('you called sampleFunc({})'.format(arg))
globals()['sampleFunc']('sample arg')
Dada uma string, com um caminho python completo para uma função, foi assim que consegui obter o resultado dessa função:
import importlib
function_string = 'mypackage.mymodule.myfunc'
mod_name, func_name = function_string.rsplit('.',1)
mod = importlib.import_module(mod_name)
func = getattr(mod, func_name)
result = func()
A melhor resposta de acordo com Perguntas frequentes sobre programação Python seria:
functions = {'myfoo': foo.bar}
mystring = 'myfoo'
if mystring in functions:
functions[mystring]()
A principal vantagem desta técnica é que as strings não precisam corresponder aos nomes das funções.Esta também é a principal técnica usada para emular uma construção de caso
A resposta (espero) que ninguém nunca quis
Eval gosta de comportamento
getattr(locals().get("foo") or globals().get("foo"), "bar")()
Por que não adicionar importação automática
getattr(
locals().get("foo") or
globals().get("foo") or
__import__("foo"),
"bar")()
Caso tenhamos dicionários extras, queremos verificar
getattr(next((x for x in (f("foo") for f in
[locals().get, globals().get,
self.__dict__.get, __import__])
if x)),
"bar")()
Precisamos ir mais fundo
getattr(next((x for x in (f("foo") for f in
([locals().get, globals().get, self.__dict__.get] +
[d.get for d in (list(dd.values()) for dd in
[locals(),globals(),self.__dict__]
if isinstance(dd,dict))
if isinstance(d,dict)] +
[__import__]))
if x)),
"bar")()
Pelo que vale a pena, se você precisasse passar o nome da função (ou classe) e o nome do aplicativo como uma string, você poderia fazer o seguinte:
myFnName = "MyFn"
myAppName = "MyApp"
app = sys.modules[myAppName]
fn = getattr(app,myFnName)
Experimente isso.Embora ainda use eval, ele só o usa para convocar a função do contexto atual.Então, você tem a função real para usar como desejar.
O principal benefício disso para mim é que você receberá erros relacionados à avaliação no momento de invocar a função.Então você vai conseguir apenas os erros relacionados à função quando você chama.
def say_hello(name):
print 'Hello {}!'.format(name)
# get the function by name
method_name = 'say_hello'
method = eval(method_name)
# call it like a regular function later
args = ['friend']
kwargs = {}
method(*args, **kwargs)
nada do que foi sugerido me ajudou.Eu descobri isso embora.
<object>.__getattribute__(<string name>)(<params>)
Estou usando python 2.66
Espero que isto ajude
Como esta pergunta Como chamar métodos dinamicamente dentro de uma classe usando atribuição de nome de método a uma variável [duplicado] marcado como duplicado como este, estou postando uma resposta relacionada aqui:
O cenário é que um método em uma classe deseja chamar outro método na mesma classe dinamicamente. Adicionei alguns detalhes ao exemplo original que oferece um cenário mais amplo e claro:
class MyClass:
def __init__(self, i):
self.i = i
def get(self):
func = getattr(MyClass, 'function{}'.format(self.i))
func(self, 12) # This one will work
# self.func(12) # But this does NOT work.
def function1(self, p1):
print('function1: {}'.format(p1))
# do other stuff
def function2(self, p1):
print('function2: {}'.format(p1))
# do other stuff
if __name__ == "__main__":
class1 = MyClass(1)
class1.get()
class2 = MyClass(2)
class2.get()
Saída (Python 3.7.x)
função1:12
função2:12