def moyenne (t):
    return somme (t) / len (t)

def somme (t):
    s = 0
    for i in range (len (t)):
        s = s + t[i]
    return s

def max (a, b):
    if a > b:
        return a
    else:
        return b

def maxt(t):
    mc = t[0]
    for i in range (1, len(t)):
        mc = max (mc, t[i])
    return mc

###########################################################################
## Notre implémentation pédagogique de shallow_copy.

## Notre implémentation marche pour les entiers, les booléens, les réels, les
## chaînes, les liste, les n-uplets et les dictionnaires.

## «error» est incorrect, mais j'ai ingoré le problème : on veut juste provoquer
## une erreur.
def shallow_copy (x):
    if type (x) == type (1) or type (x) == type (1.0) or type (x) == type (True) or type (x) == type (""):
        return x
    elif type (x) == type ([]):
        return shallow_copy_list(x)
    elif type (x) == type ((1, 2)):
        return shallow_copy_tuple(x)
    elif type (x) == type ({1: 2}):
        return shallow_copy_dictionary(x)
    else:
        error

def shallow_copy_list (x):
    r = []
    for e in x:
        r.append (e)
    return r

## Je montré ça comme un exemple d'utilisation maline du typage dynamique, mais
## en réalité l'appel à shallow_copy_list n'était pas vraiment nécessaire ici :
## «tuple (x)» aurait produit une nouvelle n-uplet avec les éléments de la liste,
## ce qui est fait une shallow copy.
def shallow_copy_tuple (x):
    return tuple (shallow_copy_list (x))

def shallow_copy_dictionary (x):
    r = {}
    for k in x:
        r[k] = x[k]
    return r


###########################################################################
## Notre implémentation pédagogique de deep_copy.

## Très similaire à shallow_copy !  J'ai juste copié le code, renommé «shallow»
## en «deep» et ajouté des appels recursif à deep_copy.

## J'ai expliqué au tableau que notre version ne peut pas cloner les structures
## circulaires.  Ella a un autre problème aussi : il n'y aura aucun sharing dans
## la structure de donnée renvoyée, même si il y avait du sharing dans la structure
## originale.

def deep_copy(x):
    if type(x) == type(1) or type(x) == type(1.0) or type(x) == type(True) or type(x) == type(""):
        return x
    elif type(x) == type ([]):
        return deep_copy_list (x)
    elif type(x) == type ((1,2)):
        return deep_copy_tuple (x)
    elif type(x) == type ({1: 2}):
        return deep_copy_dictionary (x)
    else:
        error

def deep_copy_list(x):
    r = []
    for e in x:
        r.append (deep_copy (e))
    return r

def deep_copy_tuple (x):
    return tuple(deep_copy_list (x))

def deep_copy_dictionary (x):
    r = {}
    for k in x:
        r[deep_copy (k)] = deep_copy (x[k])
    return r

def palyndrome (a):
    taille = len (a)
    limite = taille / 2 # Division entière : c'est intentionnel
    for i in range (0, limite):
        if a[i] != a[taille - i - 1]:
            return False
    return True

def gauss10 ():
    s = 0
    for i in range (1, 11):
        s = s + i
    return s

def print_list (x):
    for i in range (len (x)):
        print x[i]

def print_list (x):
    for e in x
        print e

def my_len (x):
    t = 0
    for useless in x:
        t = t + 1
    return t