您可以在while循环中更改函数名称吗-python3

Question

I was wondering if you can change function names while in a while loop? For example, if I had an X amount of functions called function1, function2, function3, functionX, could I execute the function with the loop number tracker? Something like this:

def function1():
    do this

def function2():
    do that

def function3():
    do something

def...

i = 1

while i <= X:
    function(i)
    i += 1

Obviously this doesn't work, but is there a way to make it work?

EDIT: I'm new to python so I wanted to try to make a simple project rather than watching tutorials. I'm, trying to make a "hangman" game. The loop is needed to draw the hanger and the parts depending on the right or wrong answer. Each function has the code to draw the next step. There is an if statement in the loop, if the user answers the wrong letter then function(i) should be used (depending on the amount of times the user has missed).

Thank you!

Answer 1

You can put all of them in a list and call them by index. Then you don't need to worry about what they are called, just the order that they should be called, which seems to be the most important thing for you.

def function1():
    print('function 1')


def function2():
    print('function 2')


def function3():
    print('function 3')

functions = [function1, function2, function3]


i = 1

while i <= 3:

    functions[i-1]() #note the () to call the function

    i += 1

Answer 2

您可以使用 eval("function1()") 来运行 function1，这样您就可以在每次 for 循环运行时更改字符串。

Answer 3

First things first: if you could, should you?

Second thing: yes, you can, but probably shouldn't.

def function1():
    return 1

def function2():
    return 2

# ...

i, num = 1, 2 # num can be as much as you have defined functions
while i < num + 1:
    print(globals()[f'function{i}']())
    i += 1

# out
# 1
# 2

Maybe you should take a look into lambda expressions and globals .

As stated in @Alon 's answer, you can also you eval . But keep in mind that both solutions are a result of bad design and I repeat: being able is not a good reason to do it .

Answer 4

You can assign functions to variables in python. This variable can then be overwritten with another function. An example of this can be seen here:

def fn1(x):
   return x

def fn2(x):
   return x*2


test = fn1
print(test(4)) # prints 4

test = fn2
print(test(4)) # prints 8

Applying this to your example we can create an array containing all your functions, which you iterate over the indexes or a dictionary where the key is your id and the value is your function:

def function1(args):
    do this

def function2(args):
    do that

def function3(args):
    do something

myfunctions = {'1':function1,'2':function2, etc...}

i = 1
while i <= len(myfunctions):
    myfunctions[str(i)](args)
    i += 1

or using the list method:

def function1(args):
    do this

def function2(args):
    do that

def function3(args):
    do something

myfunctions = [function1,function2, etc...]

for i in range(myfunctions):
    myfunctions[i](args)

I would say that if you are running all the functions 0:X the list method is simpler, but if you have data telling you which one to run a key-value dictionary would be easier.

In an ideal world, you would have one function that does different things based on its input.

Note on eval As per the other answers, the use of eval would also work, however in the interest of efficiency and good coding practice it is better avoided if possible!

Answer 5

In your case, when one function follows another, I would do something like this:

def function1():
    do this
    return function2

def function2():
    do that
    return function3

def function3():
    do something
    return fail?

def...

function = function1
i = 1
while i <= X:
    function = function()
    i += 1

where there is always a function called, but it changes each iteration to the next one.

Firstly, I wanted to suggest the same as others with writing functions in lists or dictionaries and iterating through them. But I think returning the next function is better for your case.