#!/usr/bin/env python
# coding: utf-8

# # Les tableaux :
# 
# Un tableau est une suite ordonnée d'éléments. Ces éléments sont séparés par des virgules et entourés par des crochets.
# 
# En Python, un tableau est de type list.
# 
# > A voir sur Lumni : https://www.lumni.fr/video/notion-de-listes-en-informatique-et-application-aux-images-numeriques
# 
# ## Exemples :
# 
# ### Un tableau vide :

# In[ ]:


monTableau = []
monTableau, type(monTableau)


# ### Un tableau d'entiers :

# In[ ]:


tab_entiers = [ 1, 2, 3, 4, 5]
tab_entiers, type(tab_entiers)


# ### Un tableau de chaines de caractères :

# In[ ]:


tab_chaines = [ "toto", "titi", "tata", "tutu", "tete"]
tab_chaines, type(tab_chaines)


# ### Un tableau de tuples :

# In[ ]:


tab_tuples = [(1, 2, 'moi'),(3, 4, 'toi'),(5, 6, 'nous')]
tab_tuples, type(tab_tuples)


# ### Un tableau de tableau :

# In[ ]:


tab_tableaux = [[0, 2, 4, 6, 8],[1, 3, 5, 7, 9]]
tab_tableaux, type(tab_tableaux)


# > **Présentation sous forme de matrice en ligne et colonne :**
# >
# > ```python
# matrice = [[1, 2, 3],
#            [4, 5, 6],
#            [7, 8, 9]]
# ```
# > Pour cibler un élément particulier de la matrice, on utilise la notation avec "doubles crochets" : matrice[ligne][colonne] 

# In[ ]:


tab_tuples = [(1, 2, 'moi'),
              (3, 4, 'toi'),
              (5, 6, 'nous')]

tab_tableaux = [[0, 2, 4, 6, 8],
                [1, 3, 5, 7, 9]]


# ## Lecture d'un tableau par index :
# 
# Le premier élément est toujours à l'index `0`, le dernier est toujours à l'index `-1` :

# <style type="text/css">
# .tg  {border-collapse:collapse;border-spacing:0;border-color:#aabcfe;}
# .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#aabcfe;color:#669;background-color:#e8edff;}
# .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#aabcfe;color:#039;background-color:#b9c9fe;}
# .tg .tg-htl6{font-size:14px;font-family:"Comic Sans MS", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:middle}
# .tg .tg-yaja{font-size:14px;font-family:"Comic Sans MS", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:top}
# .tg .tg-l3hy{background-color:#D2E4FC;font-size:14px;font-family:"Comic Sans MS", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:middle}
# .tg .tg-adyi{background-color:#D2E4FC;font-size:14px;font-family:"Comic Sans MS", cursive, sans-serif !important;;border-color:inherit;text-align:center;vertical-align:top}
# </style>
# <table class="tg">
#   <tr>
#     <th class="tg-htl6">"toto"</th>
#     <th class="tg-htl6">"titi"</th>
#     <th class="tg-htl6">"tata"</th>
#     <th class="tg-htl6">"tutu"</th>
#     <th class="tg-htl6">"tete"</th>    
#   </tr>
#   <tr>
#     <td class="tg-yaja">0</td>
#     <td class="tg-yaja">1</td>
#     <td class="tg-yaja">2</td>
#     <td class="tg-yaja">3</td>
#     <td class="tg-yaja">4</td>    
#   </tr>
#   <tr>
#     <td class="tg-adyi">-5</td>
#     <td class="tg-adyi">-4</td>
#     <td class="tg-adyi">-3</td>
#     <td class="tg-adyi">-2</td>
#     <td class="tg-adyi">-1</td>
#   </tr>
# </table>

# ### Accès à un élément :

# In[ ]:


tab_chaines[-2]


# In[ ]:


tab_tuples[1][2]


# In[ ]:


"toto" in tab_chaines


# In[ ]:


tab_chaines.index("toto")


# ### Parcours des éléments d'un tableau :

# In[ ]:


for element in tab_chaines :
    print(element)


# La fontion `len(monTableau)` renvoie la taille d'un tableau, le nombre d'éléments qu'il contient :

# In[ ]:


for i in range(len(tab_chaines)) :
    print(tab_chaines[i])


# In[ ]:


for i in range(len(tab_tableaux)) :
    for j in range(len(tab_tableaux[i])) :
        print(tab_tableaux[i][j])


# ## Modification du contenu d'un tableau :
# 
# Contrairement à un `tuple`, un tableau est mutable, c'est à dire que l'on peut modifer l'un de ses éléments.
# 
# ### Modifier un élément :

# In[ ]:


tab_chaines[4]="tyty"
tab_chaines


# ### Ajouter/supprimer un élément :
# - Pour ajouter un élément à une liste on utilise la méthode **``append()``**

# In[ ]:


tab_chaines.append("toto")
tab_chaines


# In[ ]:


# Remplissage d'un tableau dans une boucle
tab_cubes = [] # on déclare un tableau vide
for k in range(10):
    tab_cubes.append(k**3) # on ajoute le cube de l'indice à chaque tour de boucle
tab_cubes


# - Pour supprimer un élément à une liste on utilise la méthode **``remove()``** ou encore la fonction **`del()`**

# In[ ]:


tab_chaines.remove("toto")
tab_chaines


# In[ ]:


tab_chaines.remove(tab_chaines[-1])
tab_chaines


# In[ ]:


del(tab_chaines[0])
tab_chaines


# ### Concaténation :

# In[ ]:


tab_chaines = ["toto"] + tab_chaines + ["tete"]
tab_chaines


# In[ ]:


monTableau = [0] * 6
monTableau


# ### Autre méthodes :
# 
# > Placer le curseur après le point et appuyer sur la touche `Tab`

# In[ ]:


monTableau.


# ## Tableau par compréhension :
# 
# Il est possible de créer un tableau et de le remplir en une ligne grâce à la compréhension de tableau :

# In[ ]:


new_tab_entier = [n for n in range(1,6)]
new_tab_entier


# In[ ]:


new_tab_cubes = [k**3 for k in range(10)]
new_tab_cubes


# In[ ]:


ma_liste_de_mots = [ "Cosinus", "Sinus", "Tangente", "Cotangente" ]
new_tab = [ len(mot) for mot in ma_liste_de_mots]
new_tab


# In[ ]:


tab_input = [input("saisir un entier positif = ") for n in range(4)]
tab_decimal = [int(n) for n in tab_input]
tab_binaire = [bin(n) for n in tab_decimal]
tab_hexadecimal = [hex(n) for n in tab_decimal]
tab_input, tab_decimal, tab_binaire, tab_hexadecimal


# La compréhension de tableau permet de rajouter une condition `if` :

# In[ ]:


new_tab_tableaux = [[i for i in range(10) if i % 2 == 0],[j for j in range(10) if j % 2 == 1]]
new_tab_tableaux


# In[ ]:


multiples_de_cinq_ou_de_sept_mais_pas_des_deux = [n for n in range(100) if ((n % 5 == 0 or n % 7 == 0) and n % 35 != 0)]
multiples_de_cinq_ou_de_sept_mais_pas_des_deux


# > **Une instruction par compréhension se construit de la façon suivante :**
# >```python
# [fonction for i in sequence condition]
# ```

# ## Identité et copie de tableau :

# Deux tableaux qui sont liés par une relation d'égalité pointent vers la même adresse mémoire.
# 
# La modification de l'un entraîne la modification de l'autre.
# 
# Si l'on souhaite mémoriser l'état initial d'un tableau avant sa modification il faut le copier au préalable avec la méthode `copy()`...

# In[ ]:


t1 = [1,2,3]
t2 = t1
t3 = t1.copy()
t1, t2, t3


# In[ ]:


t1[0] = 5
t1, t2, t3


# ### Observation avec Python tutor

# In[ ]:


from metakernel import register_ipython_magics
register_ipython_magics()


# In[ ]:


get_ipython().run_cell_magic('tutor', '', 't1 = [1,2,3]\nt2 = t1\nt3 = t1.copy()\nt1[0] = 5\nt3[1] = 7\n')


# <h3 class='fa fa-code' style="color: darkorange"> A programmer vous-même :</h3>
# 
# 
# #### EXERCICE n°1 :
# 
# 1- Écrire une fonction ``additionne_element(tableau)`` qui retourne la somme des éléments d’un tableau.
# 
# Tester pour ``tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]``
# 
# 2- Écrire une fonction ``moyenne_element(tableau)`` qui retourne la moyenne des éléments d’un tableau.
# 
# Tester pour ``tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]``
# 
# #### EXERCICE n°2 :
# 
# Écrire une fonction ``supprimer_doublons(tableau)`` qui permet de supprimer les doublons d'un tableau.
# 
# Tester pour ``tableau = [20,41,52,41,20,78,41,63,52,20]``
# 
# #### EXERCICE n°3 :
# 
# 1- Écrire une fonction ``multiplie_par_2(tableau)`` qui multiplie par 2 chaque élément du tableau
# 
# Tester pour ``tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]``
# 
# 2- Écrire une compréhension de tableau qui permet d’effectuer cette tâche.
# 
# 3- Compléter cette instruction pour que le tableau ne contienne que des valeurs supérieures à 50

# ****
# ## Références aux programmes :
# 
# <style type="text/css">
# .tg  {border-collapse:collapse;border-spacing:0;}
# .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}
# .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}
# .tg .tg-cv16{font-weight:bold;background-color:#dae8fc;border-color:inherit;text-align:center}
# .tg .tg-xldj{border-color:inherit;text-align:left}
# </style>
# <table class="tg">
#   <tr>
#     <th class="tg-cv16">Contenus</th>
#     <th class="tg-cv16">Capacités attendues</th>
#     <th class="tg-cv16">Commentaires</th>
#   </tr>
#   
#   <tr>
#     <td class="tg-xldj">Tableau indexé,<br> tableau donné en compréhension</td>
#     <td class="tg-xldj">Lire et modifier les éléments d’un tableau grâce à leurs index.<br> Construire un tableau par compréhension.<br> Utiliser des tableaux de tableaux pour représenter des matrices : notation a [i] [j].<br>Itérer sur les éléments d’un tableau.
# </td>
#     <td class="tg-xldj">Seuls les tableaux dont les éléments sont du même type sont présentés.<br> Aucune connaissance des
# tranches (slices) n’est exigible. <br> L’aspect dynamique des tableaux de Python n’est pas évoqué.<br> Python identifie listes et tableaux. <br>Il n’est pas fait référence aux tableaux de la bibliothèque NumPy.
# </td>
#   </tr>
#   
# </table>

# ## Pour Aller plus loin :
# Le type `list` de Python permet de créer des tableaux (des listes de listes) pas obligatoirement homogènes en taille, ni en type :
# 

# In[ ]:


monTableau= [[1,2,3,4],["toto","titi","tata"], [-3.14, 0.5, 1, 2.35, 6.48]]
monTableau[1][0], type(monTableau)


# > La bibliothèque **``numpy``** permet de gérer des tableaux numériques homogènes, des matrices...