Is there anyway to use a object's name after passing it arbitrarily?

Question

I need to pass a various amount of ships into the code but still be able to use their name when I am inside the hit_or_miss function. Is there a way to pass an arbitrary amount of parameters (as objects) but still access them specifically by name?

hit_or_miss(ship_1, ship_2, ship_3)

def hit_or_miss(*args):    
# Everything from here on should go in your for loop!
# Be sure to indent four spaces!
    ships_sunk = 0
    for turn in range(4):
        print "Turn", turn + 1
        guess_row  = int(raw_input("Guess Row:"))
        guess_col  = int(raw_input("Guess Col:"))
        guess_loc  = ((guess_row,guess_col))
        # A correct guess congratulates and exits the game
        if guess_loc in ship_1.location or \
           guess_loc in ship_2.location or \
           guess_loc in ship_3.location:
            print "Congratulations! You sunk a battleship!"
            ships_sunk += 1
            board[guess_row - 1][guess_col - 1] = "H"

Answer 1

You could try to replace your if statement with a loop over your args.

hit_or_miss(ship_1, ship_2, ship_3)

def hit_or_miss(*args):    
    ships_sunk = 0
    for turn in range(4):
        print "Turn", turn + 1
        guess_row  = int(raw_input("Guess Row:"))
        guess_col  = int(raw_input("Guess Col:"))
        guess_loc  = ((guess_row,guess_col))
        # A correct guess congratulates and exits the game

        # Try something like this
        for ship in args:
            if guess_loc in ship.location:
                print("Congratulations! You sunk a {}".format(ship.ship_type))
                ships_sunk +=1
                board[guess_row - 1][guess_col - 1] = "H"

I'm assuming args are classes that you're passing in that you could add a ship_type attribute. (I didn't test this, so you may have to tweak it.)

Note that inside of your function here, *args is now the iterable args. The name args is arbitrary, as long as you include the * in the function definition. You could use def hit_or_miss(*args) and then loop over ships. This allows you to loop through everything you pass into your function.

You might also be interested in **kwargs, but I don't think that's necessary for your function.

Answer 2

You could use kwargs. They basically translate your key-value arguments to a dictionary that you can access within your function:

def hit_or_miss(**kwargs): 
    print kwargs

hit_or_miss(ship1=ship1, ship2=ship2)
>>> {'ship2': *yourshipobject*, 'ship1': *yourshipobject*}

Answer 3

There is no way of doing it without inspecting the upper stack frame, and inspecting the stack frame is generally a bad idea.

A better approach would be to inject an attribute, perhaps ship._name, to the class, and later on map it:

ships = {ship._name: ship for ship in args}

Then you may access it as a normal dict:

ships["ship1"].location

Or iterate over them:

for ship in ships.values():
    print(ship.location)

Using **kwargs would still require you to pass the name along and I believe it won't be as modular as injection in this case.

Answer 4

1) Why can't you use a list of ships?

def hit_or_miss(ships): 
  for ship in ships: pass

hit_or_miss([ship1, ship2, ship3]) 

2) Or declare hit_or_miss with a variable number of arguments?

def hit_or_miss(*ships): 
  for ship in ships: pass

hit_or_miss(ship1, ship2, ship3) 

3) If you need named arguments, pass a dictionary to the function

def hit_or_miss(**ships): 
  for ship in ships: pass
  # ships are accessed with ships['ship1'] etc. 
hit_or_miss(ship1=Ship(...), ship2=Ship(...))

4) DO NOT DO THIS, but you can get the desired behaviour by dynamically evaluating new variables. This makes your code difficult to read and debug, and possibly exposes security vulnerabilities. Unless you have an extremely good reason for doing this, use one of the first three.

def hit_or_miss(ships): 
  for i in range(len(ships)): 
    exec(('ship{} = ships[{}]').format(i, i))
  # we can access `ship1` here now. 

hit_or_miss([ship1, ship2, ship3])

Answer 5

I think you misunderstand the word "arbitrarily". This means that there is a variable amount of ships passed to the function, not just 3.

If your function should take exactly 3 ships that you refer to by name then the function should take 3 perameters:

def hit_or_miss(ship1, ship2, ship3):

This would not allow for variable number of ships but would work better then your current version!

As you have the function written you are using the global variables ship_1, ship_2, ship_3 so if I called your function like:

hit_or_miss(a,b,c)

Your function would look for globally defined variables called ship_1, ship_2, ship_3 and completely ignore the arguments!

Similarly how do you expect to refer to a variable number of ships by name? what If you call the function like:

hit_or_miss(ship_a, ship_b) #only 2 arguments, no ship_3

hit_or_miss(s1, s2, s3, s4) #4 arguments, how do you name the fourth?

So no there is no way to take an arbitrary number of arguments and refer to all of them by name. However you only use the ships in this one condition:

    if guess_loc in ship_1.location or \
       guess_loc in ship_2.location or \
       guess_loc in ship_3.location:

Which looks a lot like you want to check if any of the conditions are true, so the equivelent with a variable number of ships would be:

if any((guess_loc in ship.location) for ship in args):

This will check if the condition is met for any of the ships passed in the arguments.