tup = (1, 2, 3)

# informations sur un tuple
print('TUPLE tup = ', tup)
print("nombre d'éléments : ", len(tup))
print("2ème élément : ", tup[1])
print("id(tup): ", id(tup))

# tentative de modification d'une valeur du tupple
tup[1] = 4
# c'est un non mutable

# nouveau tuple -> nouvelle référence
print('id(tup): ', id(tup))
tup = (4, 5)
print('id(tup): ', id(tup))
print('tup = ', tup)

ch = 'bonkour le monde'

print('id(ch) = ', id(ch))
print('ch[3] = ', ch[3])

try:
    ch[3] = 'j'
except TypeError as e:
    print("error: ", e)
ch = 'bonjour le monde'
print('id(ch) = ', id(ch))
print(ch)

liste1 = [1, 2, 3]
print('LISTE liste1 = ', liste1)
print("nombre d'éléments : ", len(liste1))
print("2ème élément : ", liste1[1])
print("ref liste1: ", id(liste1))
liste1[1] = 4
print('liste1 = ', liste1, ' ; id(liste1) = ', id(liste1))
liste1 = [5, 6]
print('liste1 = ', liste1, ' ; id(liste1) = ', id(liste1))

# attention encore aux références
liste2 = liste1
liste2[0] = 7
print('liste1 = ', liste1, ' ; liste2 = ', liste2)
print('id(liste1)= ', id(liste1), ' ; id(liste2) = ', id(liste2))
liste2 = liste1[:]
liste2[0] = 9
print('liste1 = ', liste1, ' ; liste2 = ', liste2)
print('id(liste1) = ', id(liste1), ' ; id(liste2) = ', id(liste2))

%load_ext tutormagic

%%tutor
liste1 =  [5, 6]
# attention encore aux références
liste2 = liste1
liste2[0] = 7
print('liste = ', liste, ' ; liste2 = ', liste2)
print('id(liste1)= ', id(liste1), ' ; id(liste2) = ', id(liste2))
liste2 = liste1[:]
liste2[0] = 9
print('liste1 = ', liste1, ' ; liste2 = ', liste2)
print('id(liste1) = ', id(liste1), ' ; id(liste2) = ', id(liste2))

# attention encore encore aux références
liste3 = [[0] * 3] * 4
print('liste3 = ', liste3)
print('id(liste3): ', id(liste3))
liste3[0][0] = 2
print('liste3 = ', liste3)
print('id(liste3[0]): ', id(liste3[0]), ' ; id(liste3[1]): ', id(liste3[1]),
      ' ; id(liste3[2]): ', id(liste3[2]), ' ; id(liste3[3]): ', id(liste3[3]))
liste3 = [[0] * 3 for i in range(4)]
liste3[0][0] = 2
print('liste3 = ', liste3)
print('id(liste3[0]): ', id(liste3[0]), ' ; id(liste3[1]): ', id(liste3[1]),
      ' ; id(liste3[2]): ', id(liste3[2]), ' ; id(liste3[3]): ', id(liste3[3]))

%%tutor
# attention encore encore aux références
liste3 = [[0] * 3] * 4
print('liste3 = ', liste3)
print('id(liste3): ', id(liste3))
liste3[0][0] = 2
print('liste3 = ', liste3)
print('id(liste3[0]): ', id(liste3[0]), ' ; id(liste3[1]): ', id(liste3[1]),
      ' ; id(liste3[2]): ', id(liste3[2]), ' ; id(liste3[3]): ', id(liste3[3]))
liste3 = [[0] * 3 for i in range(4)]
liste3[0][0] = 2
print('liste3 = ', liste3)
print('id(liste3[0]): ', id(liste3[0]), ' ; id(liste3[1]): ', id(liste3[1]),
      ' ; id(liste3[2]): ', id(liste3[2]), ' ; id(liste3[3]): ', id(liste3[3]))

tt1 = set((1, 2, 3))
tt2 = set([3, 4])
print('intersection : ', tt1 & tt2)
print('union : ', tt1 | tt2)
print('différence : ', tt1 - tt2)  # ens. vide == set()
tt3 = set([1, 2, 3, 2, 2])
print("set de [1, 2, 3, 2, 2]: ", tt3)

# on défini une fonction qui affiche une chaîne de caractères
def une_fonction():
    print("La fonction a été appelée.")

# on défini un dictionnaire. Celui-ci peut contenir en même temps des éléments de type différents
# un élément d'un dictionnaire est défini par un couple clé-valeur
# les dictionnaires ne sont pas ordonnés, chercher le ième élément n'a pas de sens
d = {'un': 1, 'deux': 'two', 3: 'trois'}

# modification de la valeur de l'élément de clé 3

d[3] = 'three'
print('d[3]: ', d[3])
print('d: ', d)

# ajout d'un nouvel élément avec comme clé le caractère '4' et de valeur 4
d['4'] = 4
print("d['4']: ", d['4'])
print("d: ", d)

# intérogation d'une clé qui n'existe pas dans le dictionnaire
d[5]

# il est possible et parfois très pratique de faire un dictionnaire de fonctions.
# ceci évite un succession de if/elsif en ne faisant qu'un appel à d[clé]()

une_fonction()  # appel de la fonction de manière classique
 
# on associe à la clé '4' la fonction précédente
d['4'] = une_fonction

# notez bien qu'il n'y a pas de parenthèses après le nom de la fonction
print('d: ', d)
print('d[4]: ', d['4'])

# appel de la fonction à travers le dictionnaire
d['4']()

# que se passe-t-il si on met les parenthèses après le nom de la fonction ?
d['4'] = une_fonction()
print('d: ', d)

# essayons de l'appeler comme précédemment
d['4']()

# Soit une grille de 3 cases sur 3 cases avec les valeurs suivantes:
M3x3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
BSUP = 2  # les bornes des positions sont entre 0 et BSUP
i, j = 0, 0  # les variables que nous utiliserons pour indiquer notre position

# on définit un dictionnaire de fonctions pour connaitre la valeur dans la grille à partir d'une position (i,j)
# dans une direction donnée: Nord, Sud, Est, Ouest
dmvt = {'N': max(j-1, 0), 'S': min(j+1, BSUP), 'E': min(i+1, BSUP),
        'O': max(i-1, 0)}

print('M3x3 = ', M3x3)
print('dmvt = ', dmvt)

# nous nous plaçons en (0,0), quelle est la valeur de la case adjacente à l'est ?
print('a droite de M['+str(i)+']['+str(j)+']', ':', M3x3[j][dmvt['E']])

# plaçons nous en (0,1), quelle est maintenant la valeur de la case adjacente à l'est ?
i += 1
print('a droite de M['+str(i)+']['+str(j)+']', ':', M3x3[j][dmvt['E']])
# et vers le sud ?
print('en dessous de M['+str(i)+']['+str(j)+']', ':', M3x3[dmvt['S']][i])

# plaçons nous en (1,1), quelle est la valeur de la case adjacente au sud ?
j += 1
print('en dessous de M['+str(i)+']['+str(j)+']', ':', M3x3[dmvt['S']][i])
# ne fonctionne pas car évalué au moment de la lecture du code par l'interpréte
# d'où les valeurs déjà calculées de dmvt, qui ne dépendent plus de i ni de j

# nous devons utiliser des fonctions qui seront appelées à la demande
# comme ces fonctions sont simples, nous pouvons utiliser des fonctions anonymes: les fonctions lambda
i, j = 0, 0
dmvt = {'N': lambda: max(j-1, 0), 'S': lambda: min(j+1, BSUP),
        'E': lambda: min(i+1, BSUP), 'O': lambda: max(i-1, 0)}

print('dmvt = ', dmvt)
print('M3x3 = ', M3x3)

# on voit bien maintenant que le dictionnaire contient des fonctions et non plus des valeurs
# essayons de nouveau nos interrogations de valeurs
print('a droite de M['+str(i)+']['+str(j)+']', ':', M3x3[j][dmvt['E']()])
i += 1
print('a droite de M['+str(i)+']['+str(j)+']', ':', M3x3[j][dmvt['E']()])
print('en dessous de M['+str(i)+']['+str(j)+']', ':', M3x3[dmvt['S']()][i])
j += 1
print('en dessous de M['+str(i)+']['+str(j)+']', ':', M3x3[dmvt['S']()][i])