A simple example: We have the following array

li = [{"id":1,"name":"ronaldo"},{"id":2,"name":"messi"}]

Now, we want to find the object in the array that has id equal to 1

1. Use method next with list comprehension

next(x for x in li if x["id"] == 1 )

2. Use list comprehension and return first item

[x for x in li if x["id"] == 1 ][0]

3. Custom Function

def find(arr , id):
    for x in arr:
        if x["id"] == id:
            return x
find(li , 1)

Output all the above methods is {'id': 1, 'name': 'ronaldo'}

If you do this it only gives the very first match, instead of comparing the whole list: find first sequence item that matches a criterion.

If you do something like this, you don't have to catch the exception but get None instead:

item = next((i for i in items if i == 'value'), None)

You can access the dict (a.k.a Hashtable) of all attributes of an object with:

ListObj[i].__dict__

Or you can only get the names of these attributes as a list with either

ListObj[i].__dict__.keys()

and

dir(ListObj[i])

Simple, Elegant, and Powerful:

A generator expression in conjuction with a builtin… (python 2.5+)

any(x for x in mylist if x.n == 10)

Uses the Python any() builtin, which is defined as follows:

any(iterable) -> Return True if any element of the iterable is true. Equivalent to:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

Here is an approach which avoids constantly rescanning the list

current_ids = set(soldier.id for soldier in user.soldiers)
for soldier_class in soldierlist:
    if soldier_class.id not in current_ids:
         user.soldiers.append( soldier_class() )

By storing all the ids in set, looking them up can be done much faster then just rescanning through the list.

If those nom's are unique keys, and all you are ever going to do is access your persons using this unique key you should indeed rather use a dictionary.

However if you want to add more attributes over time and if you like to be able to retrieve one or more person by any of those attributes, you might want to go with a more complex solution:

class Example():
    def __init__(self):
        self.__pList = []
    def addPerson(self,name,number):
        self.__pList.append(Person(name,number))
    def findPerson(self, **kwargs):
        return next(self.__iterPerson(**kwargs))
    def allPersons(self, **kwargs):
        return list(self.__iterPerson(**kwargs))
    def __iterPerson(self, **kwargs):
        return (person for person in self.__pList if person.match(**kwargs))

class Person():
    def __init__(self,name,number):
        self.nom = name
        self.num = number
    def __repr__(self):
        return "Person('%s', %d)" % (self.nom, self.num) 
    def match(self, **kwargs):
        return all(getattr(self, key) == val for (key, val) in kwargs.items())

So let's assume we got one Mike and two Dave's

a = Example()
a.addPerson('dave',123)
a.addPerson('mike',345)
a.addPerson('dave',678)

Now you can find persons by number:

>>> a.findPerson(num=345)
Person('mike', 345)

Or by name:

>>> a.allPersons(nom='dave')
[Person('dave', 123), Person('dave', 678)]

Or both:

>>> a.findPerson(nom='dave', num=123)
Person('dave', 123)

Since you've chosen to use OOP, why not implement a UserList class inherited from built-in list class?

class User(object):
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return repr(self)

    def __repr__(self):
        return "User('{0}')".format(self.name)


class UserList(list):
    def find(self, name):
        for k, user in enumerate(self):
            if user.name == name:
                return k, user

    def next_to(self, name):
        """get user next to the one of name (e.g. 'James')"""
        index, user = self.find(name)
        next_to_index = self.get_next_to_index(index)
        return self[next_to_index]

    def get_next_to_index(self, index):
        next_to_index = index + 1
        if next_to_index == len(self):
            # meaning index is already the last element, need to reset index
            next_to_index = 0
        return next_to_index


users = UserList()
users.append(User("Peter"))
users.append(User("James"))
users.append(User("John"))

print users.find('James')
print users.next_to('James')
print users.next_to('John')

Output:

(1, User('James'))
User('John')
User('Peter')