how to use dictionaries to store multiple functions with different argument requirements

I'm trying to build a dictionary that looks like this (for a fun project):

_cardLibrary = {
    
    
    1: {'name': 'Strike',
        'cost': 1,
        'type': 'attack',
        'rarity': 'common',
        'action': [deal_damage]
       },
    
    2: {'name': 'Defend',
        'cost': 1,
        'type': 'skill',
        'rarity': 'common',
        'action': [give_block]
       },
    
    3: {'name': 'Bash',
        'cost': 2,
        'type': 'attack',
        'rarity': 'common',
        'action': 
            [deal_damage,
             apply_status] 

       }

}

I'd like to build a function " use(i) " which takes the specific card and executes the code stored inside of 'action'. As you can see in the third element, 'action' should be able to contain multiple functions, each of them requiring specific arguments.

For instance, deal_damage requires 3 arguments. Apply status requires 4.

deal_damage(caster, target, basedamage)
apply_status(caster, target, status, intensity)

Is there any way to create a function that calls all the functions stored inside every specific card?

I would also need some way to be able to pass the actual arguments to every one of the functions... Some of the arguments could be constant values. Like, for this specific card, status is always 1 and intensity is 1. However, target and caster really need to be defined in the initial use(caster, target) function...

So far, I've tried to iterate over every single function, however, this leaves me with the problem of not being able to pass the concrete arguments to every function...

I also tried this link: https://stackoverflow.com/questions/64043601/python-iterate-through-functions-with-different-arguments

but for some reason, iIcannot make the code work

If this doesn't work at all, I was considering the possibility of making every single card a function itself, however, this is problematic for other reasons... specifically regarding scalability.

Any ideas on how can I approach this?

thank you all

You could use functools.partial to pre-define some arguments to each function. Then, when you need to call the functions, you will only need to specify the caster and target arguments:

from functools import partial

def deal_damage(caster, target, basedamage):
    print(f"{caster} dealt {basedamage} damage to {target}")

def give_block(caster, target, defense):
    print(f"{caster} blocked {defense} damage from {target}")

def apply_status(caster, target, status, intensity):
    print(f"{caster} applied {intensity}x{status} to {target}")


_cardLibrary = {
    "strike": {'name': 'Strike',
        'cost': 1,
        'type': 'attack',
        'rarity': 'common',
        'actions': [partial(deal_damage, basedamage=10)]
       },
    
    "defend": {'name': 'Defend',
        'cost': 1,
        'type': 'skill',
        'rarity': 'common',
        'actions': [partial(give_block, defense=5)]
       },
    
    "bash": {'name': 'Bash',
        'cost': 2,
        'type': 'attack',
        'rarity': 'common',
        'actions': 
            [partial(deal_damage, basedamage=5),
             partial(apply_status, status='stun', intensity=5)] 

       }
}

Note that I changed the keys of the dictionary to strings, and the 'action' key in each card to 'actions' because there can be multiple actions per card.

Then, in your game loop, you can call these partial objects like a regular function:

while True:
    print(f"You have {len(_cardLibrary)} cards: ")
    print(", ".join(_cardLibrary))
    u_in = input("What would you like to do? (or quit) ").lower()
    if u_in == "quit":
        print("Goodbye")
        break
    
    try:
        card = _cardLibrary[u_in]
    except KeyError:
        print("Invalid choice. Please choose again")
        continue
    
    print(f"You played the {card['name']} card")
    for action in card['actions']:
        print("ACTION: ", end="")
        action(caster="You", target="Enemy")

This gives the following output:

You have 3 cards: 
strike, defend, bash

What would you like to do? (or quit) strike
You played the Strike card
ACTION: You dealt 10 damage to Enemy
You have 3 cards: 
strike, defend, bash

What would you like to do? (or quit) bash
You played the Bash card
ACTION: You dealt 5 damage to Enemy
ACTION: You applied 5xstun to Enemy
You have 3 cards: 
strike, defend, bash

What would you like to do? (or quit) defend
You played the Defend card
ACTION: You blocked 5 damage from Enemy
You have 3 cards: 
strike, defend, bash

What would you like to do? (or quit) quit
Goodbye

You could make all your function parameter lists end with ,**_ which will let them receive (and ignore) parameters they're not actually processing. This will allow you to add fixed value parameters directly in the _cardLibrary dictionary and use it as parameters to the functions. Then define you use() function to add its own list of named arguments to the dictionary's fixed values as an override:

def deal_damage(caster,target,basedamage,**_):
    # ...


def use(card, **kwargs):
    for function in _cardLibrary[card]['action']:
        function(**{**_cardLibrary[card],**kwargs})

usage:

use(1,caster="orc",target="human") 

# assuming _cardLibrary supplies the default value for "baseDamage" on card #1