Использование словаря для выбора функции для выполнения

Не горжусь этим, но:

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

Однако я рекомендую вам поместить их в какой-либо модуль / класс, это действительно ужасно.

Если вы хотите добавить декоратор для каждой функции, вы можете определить декоратор, который добавляет каждую функцию в словарь:

def myMain(key):
    tasks = {}
    
    def task(task_fn):
        tasks[task_fn.__name__] = task_fn
    
    @task
    def ExecP1():
        print(1)
    @task
    def ExecP2():
        print(2)
    @task
    def ExecP3():
        print(3)
    @task
    def ExecPn():
        print(4)
    
    tasks['Exec' + key]()

Другой вариант - поместить все функции в класс (или в другой модуль) и использовать getattr:

def myMain(key):
    class Tasks:
        def ExecP1():
            print(1)
        def ExecP2():
            print(2)
        def ExecP3():
            print(3)
        def ExecPn():
            print(4)
    
    task = getattr(Tasks, 'Exec' + key)
    task()

Упростите, упростите, упростите:

def p1(args):
    whatever

def p2(more args):
    whatever

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

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

Это все, что вам нужно.

Вы можете рассмотреть возможность использования dict.get с вызываемым значением по умолчанию, если name относится к недопустимой функции -

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

(Подобрал этот изящный трюк от Мартин Питерс)

Упростить, упростить, упростить + СУХОЙ:

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

@task
def p1():
    whatever

@task
def p2():
    whatever

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

Это вызовет методы из словаря

Это оператор переключения Python с вызовом функции

Создайте несколько модулей в соответствии с вашими требованиями. Если вы хотите передать аргументы, пройдите.

Создайте словарь, который будет вызывать эти модули в соответствии с требованиями.

    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

Вы можете просто использовать

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

for item in myItems:
    myDict[item]()

Часто классы используются для включения методов, и ниже приводится расширение ответов выше с методом по умолчанию в случае, если метод не найден.

class P:

     def p1(self):
         print('Start')

     def p2(self):
         print('Help')

     def ps(self):
         print('Settings')

     def d(self):
         print('Default function')

     myDict = {
         "start": p1,
         "help": p2,
         "settings": ps
     }

     def call_it(self):
         name = 'start'
         f = lambda self, x : self.myDict.get(x, lambda x : self.d())(self)
         f(self, name)


 p = P()
 p.call_it()

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

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

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

}

name=input("enter P1 or P2")

myDictname

Вы зря теряете время:

1. Вы собираетесь написать много бесполезного кода и внести новые ошибки.
2. Для выполнения функции вашему пользователю в любом случае необходимо знать имя P1.
3. И т. Д. И т. Д. И т. Д.

Просто поместите все свои функции в .py файл:

# my_module.py

def f1():
    pass

def f2():
    pass

def f3():
    pass

И используйте их так:

import my_module

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

or:

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

f1()
f2()
f3()

Этого должно хватить для начала.