Máximo de dos tuplas

Question

La documentación de Python indica que, cuando se llama con más de un argumento, max() devuelve el más grande de los argumentos.

>>> a = (1, 1, 1, 9) 
>>> b = (4, 5, 6) 
>>> max(a, b) 
(4, 5, 6) 

lo que define cómo gran una tupla, en este contexto, es? La tupla a tiene un mayor número de elementos (cuatro contra tres) y su valor máximo (9) es mayor que el número máximo que se puede encontrar en b (6), por lo que según cualquier criterio hubiera esperado es el devuelto. ¿Cómo se comparan las tuplas por max()?

Answer 1

tuplas como todas las demás secuencias se ordenan lexicográfico: del orden de dos tuplas se decide por la primera posición en la que las tuplas difieren. Citando de python reference:

tuplas y las listas se comparan lexicográficamente usando comparación de elementos correspondientes.

Sus dos tuplas difieren en la primera posición y desde el 4> 1, tenemos

>>> (4, 5, 6) > (1, 1, 1, 9) 
True 

Answer 2

Se comparan un elemento a la vez, al igual que cualquier otra secuencia. Es (probablemente) más fácil de entender si se compara con la comparación de cadenas:

>>> (1, 2, 3) > (1, 2, 4) 
False 
>>> (2, 2, 3) > (1, 2, 4) 
True 
>>> 'abc' > 'abd' 
False 
>>> 'bbc' > 'abd' 
True 

Answer 3

De izquierda a derecha se compara cada elemento de las tuplas hasta que encuentra uno más grande que el otro. Esta tupla es devuelta. Por ejemplo

>>> a = (2,0,0,0) 
>>> b= (1,1,1,1) 
>>> max(a,b) 
(2, 0, 0, 0) 

>>> b = (2,1,1,1) 
>>> max(a,b) 
(2, 1, 1, 1) 

Después de un elemento se encuentra en una tupla que es mayor que el elemento respectivo en el otro los valores restantes no tienen efecto en el que se devuelve tupla.

Answer 4

Comparación usando < debe ser más o menos equivalente a:

def compare(a,b): 
    print "" 
    print "testing %s < %s" %(str(a),str(b)) 
    for ai,bi in zip(a,b): 
     print "comparing elements",ai,bi 
     if ai < bi: 
      return True 
     if bi < ai: 
      return False 
    if len(a)<len(b): 
     return True 
    return False 

test_cases = [tuple([1]),(1,2),(1,1),(1,1,1),(None,None,None),tuple([None]),(99,99)] 

print "running tests" 
for a in test_cases: 
    for b in test_cases: 
     assert(compare(a,b) == (a<b)) 
""" 
>>> 
running tests 

testing (1,) < (1,) 
comparing elements 1 1 

testing (1,) < (1, 2) 
comparing elements 1 1 

testing (1,) < (1, 1) 
comparing elements 1 1 

testing (1,) < (1, 1, 1) 
comparing elements 1 1 

testing (1,) < (None, None, None) 
comparing elements 1 None 

testing (1,) < (None,) 
comparing elements 1 None 

testing (1,) < (99, 99) 
comparing elements 1 99 

testing (1, 2) < (1,) 
comparing elements 1 1 

testing (1, 2) < (1, 2) 
comparing elements 1 1 
comparing elements 2 2 

testing (1, 2) < (1, 1) 
comparing elements 1 1 
comparing elements 2 1 

testing (1, 2) < (1, 1, 1) 
comparing elements 1 1 
comparing elements 2 1 

testing (1, 2) < (None, None, None) 
comparing elements 1 None 

testing (1, 2) < (None,) 
comparing elements 1 None 

testing (1, 2) < (99, 99) 
comparing elements 1 99 

testing (1, 1) < (1,) 
comparing elements 1 1 

testing (1, 1) < (1, 2) 
comparing elements 1 1 
comparing elements 1 2 

testing (1, 1) < (1, 1) 
comparing elements 1 1 
comparing elements 1 1 

testing (1, 1) < (1, 1, 1) 
comparing elements 1 1 
comparing elements 1 1 

testing (1, 1) < (None, None, None) 
comparing elements 1 None 

testing (1, 1) < (None,) 
comparing elements 1 None 

testing (1, 1) < (99, 99) 
comparing elements 1 99 

testing (1, 1, 1) < (1,) 
comparing elements 1 1 

testing (1, 1, 1) < (1, 2) 
comparing elements 1 1 
comparing elements 1 2 

testing (1, 1, 1) < (1, 1) 
comparing elements 1 1 
comparing elements 1 1 

testing (1, 1, 1) < (1, 1, 1) 
comparing elements 1 1 
comparing elements 1 1 
comparing elements 1 1 

testing (1, 1, 1) < (None, None, None) 
comparing elements 1 None 

testing (1, 1, 1) < (None,) 
comparing elements 1 None 

testing (1, 1, 1) < (99, 99) 
comparing elements 1 99 

testing (None, None, None) < (1,) 
comparing elements None 1 

testing (None, None, None) < (1, 2) 
comparing elements None 1 

testing (None, None, None) < (1, 1) 
comparing elements None 1 

testing (None, None, None) < (1, 1, 1) 
comparing elements None 1 

testing (None, None, None) < (None, None, None) 
comparing elements None None 
comparing elements None None 
comparing elements None None 

testing (None, None, None) < (None,) 
comparing elements None None 

testing (None, None, None) < (99, 99) 
comparing elements None 99 

testing (None,) < (1,) 
comparing elements None 1 

testing (None,) < (1, 2) 
comparing elements None 1 

testing (None,) < (1, 1) 
comparing elements None 1 

testing (None,) < (1, 1, 1) 
comparing elements None 1 

testing (None,) < (None, None, None) 
comparing elements None None 

testing (None,) < (None,) 
comparing elements None None 

testing (None,) < (99, 99) 
comparing elements None 99 

testing (99, 99) < (1,) 
comparing elements 99 1 

testing (99, 99) < (1, 2) 
comparing elements 99 1 

testing (99, 99) < (1, 1) 
comparing elements 99 1 

testing (99, 99) < (1, 1, 1) 
comparing elements 99 1 

testing (99, 99) < (None, None, None) 
comparing elements 99 None 

testing (99, 99) < (None,) 
comparing elements 99 None 

testing (99, 99) < (99, 99) 
comparing elements 99 99 
comparing elements 99 99"""