To get just the maximum value and not the entire object you can use a generator expression:

print(max(node.y for node in path.nodes))

You can use operator.attrgetter and the key parameter of max:

from operator import attrgetter
ancestor = max(nodes_ancestors, key=attrgetter('level'))

Below is a demonstration:

>>> from operator import attrgetter
>>> class Obj:
...     def __init__(self, val):
...         self.attr = val
...
>>> lst = [Obj(x) for x in range(10)]
>>> obj = max(lst, key=attrgetter('attr'))
>>> obj
<__main__.Obj object at 0x021C2290>
>>> obj.attr
9
>>>

max() takes a key parameter, a function that when passed one of the objects returns the value by which to compare them.

Use operator.attrgetter() to get that value:

from operator import attrgetter

max(self.allPartners, key=attrgetter('attrOne'))

This returns the matching object for which that attribute is the maximum. If you wanted to store just that maximum value itself, you have two options:

• Take the attribute from the returned object:

  max(self.allPartners, key=attrgetter('attrOne')).attrOne
  

• Pass just the attributes instead to max() with a generator expression:

  max(p.attrOne for p in self.allPartners)
  

If you find that you need to order the One classes in various directions by the same attribute again and again (to find the minimum, maximum, sort them, etc.) you may want to make your class orderable as well.

To do that, you'll need to implement some of the basic customization hooks Python will look for. With some extra trickery, you can get away with just the lower-than and equals operations, and by using the funtools.total_ordering class decorator:

from functools import total_ordering

@total_ordering
class One:
    # ...
    def __lt__(self, other):
        if not isinstance(other, type(self)): return NotImplemented
        return self.attrOne < other.attrOne

    def __eq__(self, other):
        if not isinstance(other, type(self)): return NotImplemented
        return self.attrOne == other.attrOne

Now your One class is orderable, entirely on the basis of attrOne; for the max() function, that means you can drop the key parameter altogether.

You can use the max function with a key:

max_obj = max(your_list, key=lambda p: p.x if p.x > p.y else p.y)

To get the maximum value, you can do

max_val = max_obj.x if max_obj.x > max_obj.y else max_obj.y
print(max_val) 

Or (as OP suggests)...

max_val = max(max_obj.x, max_obj.y)
print(max_val)

Find the max score first, then filter the list based on that score:

max_score = max(front_Ar, key=attrgetter('score')).score
max_ind = [obj for obj in front_Ar if obj.score == max_score]

Here's a version of something with just a simplifiedPlayerclass to help you get started. It handles ties where more than one player threw the ball the same longest distance as another.

class Player:
    def __init__(self, name, results):
        self.name = name
        self.results = results

def find_winners(players, num_contests):
    winners = []  # one (or more) player entries per contest
    for icontest in range(num_contests):
        contest_winners = []  # may hold multiple players if there are ties
        contest_longest_throw = -1
        for player in players:
            player_longest_throw = max(player.results[icontest])
            if player_longest_throw > contest_longest_throw:
                contest_longest_throw = player_longest_throw
                contest_winners = [player]
            elif player_longest_throw == contest_longest_throw:
                contest_winners.append(player)
        winners.append(contest_winners)
    return winners

# test data
players = [Player('Name1', [(7, 8, 9), (2, 3, 4), (3, 4, 5)]),
           Player('Name2', [(4, 5, 6), (8, 9, 10), (6, 7, 8)]),
           Player('Name3', [(1, 2, 3), (5, 6, 7), (9, 10, 11)]),
           # add one that will tie with first player
           Player('Name4', [(7, 8, 9), (2, 3, 4), (3, 4, 5)])]

# assumes length of first player's results is number of contests
winners_found = find_winners(players, len(players[0].results))

print("Contest  Winner(s)")
for icontest, contest_winners in enumerate(winners_found, start=1):
    print('{:^7}  {}'.format(
        icontest, ', '.join(player.name for player in contest_winners)))

Output:

Contest  Winner(s)
   1     Name1, Name4
   2     Name2
   3     Name3