what's the right way to put *arg in a tuple that can be sorted?

I want a dict or tuple I can sort based on attributes of the objects I'm using as arguments for *arg. The way I've been trying to do it just gives me AttributeErrors, which leads me to believe I'm doing it weird.

def function(*arg):
    items = {}
    for thing in arg:
        items.update({thing.name:thing})


    while True:
        for thing in items:
        ## lots of other code here, basically just a game loop.
        ## Problem is that the 'turn order' is based on whatever
        ## Python decides the order of arguments is inside "items".
        ## I'd like to be able to sort the dict based on each object's
        ## attributes (ie, highest 'thing.speed' goes first in the while loop)

The 开发者_运维百科problem is when I try to sort "items" based on an attribute of the objects I put into function(), it gives me "AttributeError: 'str' object has no attribute 'attribute'". Which leads me to believe I'm either unpacking *arg in a lousy way, or I'm trying to do something the wrong way.

while True:
    for thing in sorted(items, key=attrgetter('attribute')):

...doesn't work either, keeps telling me I'm trying to manipulate a 'str' object. What am I not doing here?

arg already is a tuple you can sort by an attribute of each item:

def function(*args):
    for thing in sorted(args, key=attrgetter('attribute')):

When you iterate over a dict, as sorted is doing, you just get the keys, not the values. So, if you want to use a dict, you need to do:

def function(*args):
    # or use a dict comprehension on 2.7+ 
    items = dict((thing.name, thing) for thing in args)

    # or just items.values on 3+
    for thing in sorted(items.itervalues(), key=attrgetter('attribute')):

to actually sort the args by an attribute. If you want the keys of the dict available as well (not necessary here because the key is also an attribute of the item), use something like:

for name, thing in sorted(items.iteritems(), key=lambda item: item[1].attribute):

Your items is a dict, you can't properly sort a dict. When you try to use it as an iterable, it silently returns its keys list, which is a list of strings. And you don't use your arg after creating a dict.

If you don't need dict lookup, as you just iterate through it, you can replace dict with list of 2-tuples (thing.name, thing), sort it by any attribute and iterate through it. You can also use collections.OrderedDict from Python 2.7 (it exists as a separate ordereddict package for earlier versions) if you really want both dict lookup and ordering.

{edit} Thanks to agf, I understood the problem. So, what I wrote below is a good answer in itself, but not when related to the question above... I let it here for the trace.

Looking to the answers, I may have not understood the question. But here's my understanding: as args is a tuple of arguments you give to your function, it's likely that none of these arguments is an object with a name attribute. But, looking to the errors you report, you're giving string arguments.

Maybe some illustration will help my description:

>>> # defining a function using name attribute
>>> def f(*args):
...      for arg in args:
...           print arg.name
>>> # defining an object with a name attribute
>>> class o(object):
...     def __init__(self, name):
...          self.name = name
>>> # now applying the function on the previous object, and on a string
>>> f( o('arg 1'), 'arg 2' )
arg 1

Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    f(o('arg 1'), 'ets')
  File "<pyshell#3>", line 3, in f
    print arg.name
AttributeError: 'str' object has no attribute 'name'

This is failing as strings have no such attribute.

For me, in your code, there is a mistake: you're trying to use attribute name on your inputs, without ever verifying that they have such an attribute. Maybe you should test with hasattr first:

>>> if hasattr(arg, 'name'):
...     print arg.name
... else:
...     print arg

or with some inspection on the input, to verify if it's an instance of a given class, known to have the requested attribute.