subplot python

Usando un diccionario para seleccionar la función para ejecutar

Question

Estoy tratando de usar la programación funcional para crear un diccionario que contenga una clave y una función para ejecutar:

myDict={}
myItems=("P1","P2","P3",...."Pn")
def myMain(key):
    def ExecP1():
        pass
    def ExecP2():
        pass
    def ExecP3():
        pass
        ...
    def ExecPn():
        pass  

Ahora, he visto un código usado para encontrar las funciones definidas en un módulo, y necesito hacer algo como esto:

    for myitem in myItems:
        myDict[myitem] = ??? #to dynamically find the corresponding function

Entonces, mi pregunta es: ¿Cómo hago una lista de todas las funciones Exec y luego las asigno al elemento deseado usando un diccionario? así que al final tendré myDict["P1"]() #this will call ExecP1()

Mi problema real es que tengo toneladas de esos elementos y estoy creando una biblioteca que los manejará, por lo que el usuario final solo necesita llamar a myMain("P1")

Creo que estoy usando el módulo de inspección, pero no estoy seguro de cómo hacerlo.

Mi razón para evitar:

def ExecPn():
    pass
myDict["Pn"]=ExecPn

es que tengo que proteger el código ya que lo estoy utilizando para proporcionar una función de secuencias de comandos dentro de mi aplicación.

Answer 1

Estás perdiendo tu tiempo:

1. Estás a punto de escribir muchos códigos inútiles e introducir nuevos errores.
2. Para ejecutar la función, su usuario necesitará saber el nombre P1 todos modos.
3. Etc., etc., etc.

Simplemente ponga todas sus funciones en el archivo .py :

# my_module.py

def f1():
    pass

def f2():
    pass

def f3():
    pass

Y úsalos así:

import my_module

my_module.f1()
my_module.f2()
my_module.f3()

o:

from my_module import f1
from my_module import f2
from my_module import f3

f1()
f2()
f3()

Esto debería ser suficiente para empezar.

Answer 2

No orgulloso de ello, pero:

def myMain(key):
    def ExecP1():
        pass
    def ExecP2():
        pass
    def ExecP3():
        pass
    def ExecPn():
        pass 
    locals()[''Exec'' + key]()

Sin embargo, recomiendo que los pongas en un módulo / clase, es realmente horrible.

Answer 3

Simplifica, simplifica, simplifica:

def p1(args):
    whatever

def p2(more args):
    whatever

myDict = {
    "P1": p1,
    "P2": p2,
    ...
    "Pn": pn
}

def myMain(name):
    myDict[name]()

Eso es todo lo que necesitas.

Puede considerar el uso de dict.get con un valor predeterminado que se puede dict.get si el name hace referencia a una función no válida:

def myMain(name):
    myDict.get(name, lambda: ''Invalid'')()

(Recogió este buen truco de Martijn Pieters)

Answer 4

Solo puedes usar

myDict = {
    "P1": (lambda x: function1()),
    "P2": (lambda x: function2()),
    ...,
    "Pn": (lambda x: functionn())}
myItems = ["P1", "P2", ..., "Pn"]

for item in myItems:
    myDict[item]()

Answer 5

Esto llamará métodos del diccionario.

Esta es una declaración de cambio de python con función de llamada

Cree algunos módulos según su requisito. Si quieres pasar argumentos entonces pasa.

Cree un diccionario, que llamará a estos módulos según el requisito.

    def function_1(arg):
        print("In function_1")

    def function_2(arg):
        print("In function_2")

    def function_3(fileName):
        print("In function_3")
        f_title,f_course1,f_course2 = fileName.split(''_'')
        return(f_title,f_course1,f_course2)


    def createDictionary():

        dict = {

            1 : function_1,
            2 : function_2,
            3 : function_3,

        }    
        return dict

    dictionary = createDictionary()
    dictionary[3](Argument)#pass any key value to call the method

Answer 6

Simplifica, simplifica, simplifica + DRY:

tasks = {}
task = lambda f: tasks.setdefault(f.__name__, f)

@task
def p1():
    whatever

@task
def p2():
    whatever

def my_main(key):
    tasks[key]()

Answer 7

# index dictionary by list of key names

def fn1():
    print "One"

def fn2():
    print "Two"

def fn3():
    print "Three"

fndict = {"A": fn1, "B": fn2, "C": fn3}

keynames = ["A", "B", "C"]

fndict[keynames[1]]()

# keynames[1] = "B", so output of this code is

# Two

Answer 8

#!/usr/bin/python

def thing_a(arg=None):
    print ''thing_a'', arg

def thing_b(arg=None):
    print ''thing_b'', arg

ghetto_switch_statement = {
    ''do_thing_a'': thing_a,
    ''do_thing_b'': thing_b
}

ghetto_switch_statement[''do_thing_a'']("It''s lovely being an A")
ghetto_switch_statement[''do_thing_b'']("Being a B isn''t too shabby either")

print "Available methods are: ", ghetto_switch_statement.keys()

Answer 9

def p1( ):
    print("in p1")

def p2():
    print("in p2")

myDict={
    "P1": p1,
    "P2": p2

}

name=input("enter P1 or P2")

myDictname