我在python中的函数被调用，即使我只是在定义它

Question

我有一个称为攻击的功能：

def attack(name,minmultiplier,maxmultiplier,critchance,attacker,attackee):
    print(attacker[0],"used",name)
    multiplier=random.randint(minmultiplier,maxmultiplier)
    crit=random.randint(critchance,100)
    if crit==100 and ((attacker[2]*multiplier*2)-attackee[3]) > 0:
        attackee[1]=attackee[1]-((attacker[2]*multiplier*2)-attackee[3])
    elif ((attacker[2]*multiplier)-attackee[3]) > 0:
        attackee[1]=attackee[1]-((attacker[2]*multiplier)-attackee[3])
    else:
        print("You fail to hit",attackee[0])
    print(attackee[0],"'s health after",attacker[0],"'s attack is",attackee[1])

我在这里对老板和球员进行一些实际的攻击：

boss=["Greed",1000,10,10,1]
slashp=attack("slash",1,2,5,player,boss)
slashb=attack("slash",1,2,5,boss,player)
kick=attack("kick",1,1,1,player,boss)
aiattacklist=[slashb]
attacknamelist=["slash","kick"]
attackfunclist=[slashp,kick]

即使我仅将这些版本保存为变量，它们仍被称为：

template used slash
You fail to hit Greed
Greed 's health after template 's attack is 1000
Greed used slash
template 's health after Greed 's attack is 58
template used kick
You fail to hit Greed
Greed 's health after template 's attack is 1000

这是python总是会做的事情吗，还是我做错了什么，因为我不想调用它们（对不起，如果我使用的术语不正确，我是一个新人）

Answer 1

您在这里调用函数：

slashp=attack("slash",1,2,5,player,boss)
slashb=attack("slash",1,2,5,boss,player)
kick=attack("kick",1,1,1,player,boss)

您将在此处存储返回值，而不是函数。

如果要存储一些预定义的参数，则可以使用另一个函数来包装调用，使用lambda（基本上是创建函数的简化形式），或者使用functools.partial()来预定义一些参数并存储新的可调用对象对于那些。

使用lambda看起来像这样：

shlashp = lambda player, boss: attack("slash", 1, 2, 5, player, boss)
shlashb = lambda player, boss: attack("slash", 1, 2, 5, boss, player)
kick = lambda player, boss: attack("kick", 1, 1, 1, player, boss)

这是假设你仍然要指定播放机， 后来调用这些函数当上老板。 例如，您将调用kick(player, boss) 。

这里不适合使用functools.partial() ，因为您正在交换boss和player论点。 您只需定义一个slash变量，然后以正确的顺序传入boss和player参数：

from functools import partial

slash = partial(attack, 'slash', 1, 2, 5)
kick = partial(attack, 'kick', 1, 1, 1)

调用slash或kick会添加任何额外的参数，因此slash(player, boss)调用函数，并将这两个参数添加到您已定义的参数上。

所有这些都使您假设自己希望能够管理多个玩家和老板。 如果您的player和boss变量是全局变量（也许只有一位玩家和一位老板在战斗），那么您在定义lambda或partial时只需要传入变量，而无需传入额外的参数。 例如：

slashp = partial(attack, 'slash', 1, 2, 5, player, boss)
slashb = partial(attack, 'slash', 1, 2, 5, boss, player)
kick = partial(attack, 'kick', 1, 1, 1, player, boss)

要让玩家踢老板，您只需调用kick() 。

partial对象和lambda之间的区别在于，您可以内省 partial对象； 您可以轻松查看定义为始终传递的参数：

>>> from functools import partial
>>> def attack(*args): return args
...
>>> demo = partial(attack, 'kick', 1, 2, 5)
>>> demo.args
('kick', 1, 2, 5)
>>> demo()
('kick', 1, 2, 5)
>>> demo('player1', 'boss2')
('kick', 1, 2, 5, 'player1', 'boss2')

partial对象不能用作类上的方法，而功能对象可以。 如果需要在类上使用此功能，请使用functools.partialmethod()对象 。

Answer 2

这就是functools.partial目的。

返回一个新的部分对象，该对象在被调用时的行为类似于使用位置参数args和关键字arguments关键字调用的func。 如果将更多参数提供给调用，则将它们附加到args。 如果提供了其他关键字参数，它们将扩展并覆盖关键字。

https://docs.python.org/2/library/functools.html#functools.partial

用法示例：

import functools
slashp = functools.partial("slash",1,2,5,player,boss)
slashp()  # actual call 

Answer 3

将您的功能包装成lambda：

slashp=lambda : attack("slash",1,2,5,player,boss)

或使用partial ：

slashp=partial(attack, name="slash",minmultiplier=1,maxmultiplier=2,critchance=5,attacker=player,attackee=boss)

Answer 4

上课似乎更合适，并在将来提供更大的灵活性

class AttackType(object):
    def __init__(name, minmult, maxmult, crit):
        self.name = name
        self.minmult = minmult
        self.maxmult = maxmult
        self.crit = crit
    def attack(self, attackee, attacker):
        // all your logic here

kick = AttackType("kick", 1, 1, 1)
##... later
kick(player, boss)