NSI - Première - Types construits

Les Chapitres de ce cours

Cliquez sur le lien du chapitre de cours à consulter:

• Les tableaux (listes)
• Les fonctions et méthodes de manipulation des tableaux
• Les n-uplets (tuple)
• les dictionnaires

Les tableaux ou listes

En python les tableaux sont des données de type list, les éléments dans un tableau sont ordonnés, on les accède avec un indice qui représente leur position dans le tableau.

# déclaration d'un objet tableau associé à la variable tab
tab = [1,2,3,4]
# affichage du premier élément du tableau qui est à l'indice 0
print("le premier élément du tableau vaut:", tab[0])
# affichage du deuxième élément du tableau qui est à l'indice 1
print("le deuxième élément du tableau vaut:", tab[1])

Voici le rendu dans la console:

Un objet list est muable ce qui veut dire que l'on peut changer son contenu.

# déclaration d'un objet tableau associé à la variable tab
tab = [1,2,3,4]
# modification du premier élément du tableau qui est à l'indice 0
tab[0] = 5
# affichage du tableau 
print("le tableau contient:", tab)

Voici le rendu dans la console:

Les éléments dans un tableau peuvent être de type quelconque. Pour des raisons de simplicité, vous ne manipulerez que des tableaux qui contiennent des éléments de même type (nombres, caractères, dictionnaires, tableau ).
Un tableau dont les éléments sont des tableaux est appelé une matrice.

# déclaration d'un tableau sans éléments associé à la variable tab
# un objet tableau est délimité par des crochets []
tab = []
# déclaration d'un tableau de nombres associé à la variable tab_1
# les éléments d'un tableau sont séparés par des virgules
tab_1 = [1,2,3,4]
# déclaration d'un tableau de chaine de caractères associé à la variable t
t = ['a','t','tata','z']
# déclaration d'un tableau de tableaux ( matrice) associé à la variable m
m = [ [80,12,1,0], [11,14,13,15],[7,3,2,9]]
# affichage du premier élément du premier tableau de m
print("l'élément m[0][0] vaut:", m[0][0] )
# affichage du deuxième élément du premier tableau de m
print("l'élément m[0][1] vaut:", m[0][1] )
# affichage du troisième élément du deuxième tableau de m
print("l'élément m[1][2] vaut:", m[1][2] )

Voici le rendu dans la console:

↑ Retour en haut

Les méthodes de manipulation des tableaux

Rappel: on applique une méthode à un objet avec le code:
nom_objet.nom_methode(argument)
Exemple:

tab = []
# la méthode append permet d'ajouter la valeur de son argument en fin de tableau
tab.append(23)

Si la méthode prend plusieurs arguments, on les sépare par une virgule:
nom_objet.nom_methode(argument1,argument2, etc..).

Voici quelques fonctions et méthodes utiles pour la manipulation d'un objet list:

• Connaitre le nombre d'éléments dans une liste : len(…)

La fonction len(...) prend en argument (entre ses parenthèses) un objet de type list ou une variable associée à un objet list, elle renvoie le nombre d'éléments de cet objet. Dans le code ci-dessous, len(tab_2) renvoie le nombre d'éléments de tab_2 variable qui est associée à l'objet tableau [1, 2, 3, 8 ], la fonction renvoie son résultat en tant que deuxième argument du print("nombre éléments:", len( tab_2)):

 # Une liste, qui contient 4 nombres, associée à la variable tab_2: 
 tab_2 = [1, 2, 3, 8 ]
 # afficher le nombre d'éléments de tab_2
 print ( "nombre éléments:", len( tab_2) )  

Le résultat:

• Position des éléments dans une liste:

  Soit la liste : tab_2 = [1, 2, 3, 8 ], le premier élément dans la liste est à l'indice (ou position) 0 et le dernier est à l'indice
  len(tab_2) -1 = 3:
  

  On peut accèder à un élément d'une liste avec le nom de la variable associée à cette liste et son indice placé entre crochets, exemple:
  

  tab_2[0] vaut 1
  tab_2[2] vaut 3
  

• Modification des éléments dans une liste

  Un objet liste est muable: on peut modifier son contenu
  

  # Une liste, qui contient 4 nombres, associée à la variable tab_2: 
  tab_2 = [1, 2, 3, 8 ]
  # On modifie l'élément à l'indice 3 avec le symbole d'affectation =
  tab_2[3] = 4
  print("les éléments du tableaux sont", tab_2)
  

  Le résultat:
  
  

• Ajouter un élément en fin de liste:

  Méthode append(..)
  

  Une méthode est une fonction qui est associée à un objet, elle s'utilise avec l'opérateur " . " selon le principe:

  variable_associée_à_objet.methode(argument1, argument2, etc..)
  

  La méthode append(..) prend un seul argument qui est l'élément à ajouter en fin de liste, exemple:
  

  # Une liste, qui contient 3 nombres, associée à la variable tab_2: 
  tab_2 = [1, 2, 3]
  # On ajoute le nombre 4 en fin de tableau
  tab_2.append(4)
  print("les éléments du tableaux sont", tab_2)
  

  Le résultat:
  
  

• Retirer un élément dans une liste:

  La méthode pop() sans argument retire et renvoie la valeur du dernier élément d'un objet liste, il faut une variable pour recueillir la valeur renvoyée:
  

  # Une liste, qui contient 3 nombres, associée à la variable tab_2: 
  tab_2 = [1, 2, 3]
  # On retire l'élément en fin de tableau
  valeur= tab_2.pop()
  print(f"l'élément retiré vaut {valeur}")
  print(f"il reste dans le tableau: {tab_2}")
  

  Le résultat:
  
  

  La méthode pop(...) peut prendre en argument l'indice d'un élément à retirer du tableau et renvoyer, il faut une variable pour recueillir la valeur renvoyée:
  

  # Une liste, qui contient 3 nombres, associée à la variable tab_2: 
  tab_2 = [1, 2, 3]
  # On retire l'élément en position 1 dans le tab_2
  valeur= tab_2.pop(1)
  print(f"l'élément retiré vaut {valeur}")
  print(f"il reste dans le tableau: {tab_2}")
  

  Le résultat:
  
  

• Parcours des éléments dans une liste:

  • Avec une boucle, pour i dans la plage nombre éléments de la liste: for i in range (len(liste))
    

  liste = [1,2,'a','bonjour']
  # Pour i dans la plage 0 à len(liste) exclu
  for i in range (len(liste)) :
      # affichage de i et de la valeur de l'élément (liste[i]) 
      print(f"l'élément à la position {i} vaut", liste[i] )
  

  Le résultat:
  
  
  
  • Avec un itérateur, pour chaque element dans tableau: for e in liste
    

  liste = [1,2,'a','bonjour']
  # Pour chaque élément e de liste
  for e in liste :
      # affichage de l'élément e 
      print(f" à cette itération l'élément vaut {e} ")
  

  Le résultat:
  
  

• Vérifier la présence d'un élément dans une liste

  On peut vérifier la présence d'un élément dans une liste avant de chercher sa position avec un test if element in liste:
  

  tab_2 = [ 2, 8, 3]
  nombre = int(input("entrez une nombre: "))
  # si le nombre saisi au clavier est dans le tableau
  if nombre in tab_2:
      print( "le nombre est bien dans le tableau")
  #sinon
  else:
      print( f"désolé {nombre} n'est pas dans le tableau")
  

  Le résultat:
  
  

• Connaitre la position d'un élément dans une liste: méthode index(..)

  la Méthode liste.index(element) permet de savoir à quelle position est élément dans liste:
  

  tab_2 = [ 2, 8, 3]
  nombre = int(input("entrez une nombre: "))
  # si le nombre saisi au clavier est dans le tableau
  if nombre in tab_2:
      # affichage de la position de nombre dans tab_2
      print( "le nombre est dans le tableau, à la position:", tab_2.index(nombre))
  else:
      print( f"désolé {nombre} n'est pas dans le tableau")
  

  Le résultat:
  
  

↑ Retour en haut

Les n-uplets (tuple)

Comme un objet list, un n-uplet (tuple) est une séquence ( un ensemble fini et ordonné d’éléments). Python propose un type d'objet appelé tuple qui est semblable à une liste mais qui n’est pas modifiable. On peut aussi dire qu’un tuple est une liste non-muable (not-mutable)

• Contruire un tuple:
  

Un tuple est donc une collection d’éléments séparés par des virgules, on l'assigne à une variable pour pouvoir le manipuler:
tup = 1,2,3
Pour reconnaitre le type d'objet tuple, on entoure les éléments du tuple de parenthèses:
tup = (1,2,3)
Les éléments d'un tuple peuvent être de n'importe quel type d'objet, objets simples ( nombres, chaines de caractères) ou construits (tuples, dictionnaires, listes, etc..), exemple:
tup_2 = ( (1,2,3), [1,2], "hello", 3.4 ) ou tup_2 = (1,2,3), [1,2], "hello", 3.4

• Accéder à un élément:
  

On utilise son indice (sa position) dans le tuple, le premier élément est à la position 0:

tup = (2, 8, 3) 
# affiche premier élément du tuple soit tup[0]
print("le premier élément du tuple vaut", tup[0])
# la fonction len est disponible pour compter le nombre d'éléments d'un tuple
nombre_elements = len(tup)
# afficher le contenu du tuple, on utilise la variable associée.
print("l'objet tuple assigné à tup contient:")
print(tup)

Voici le rendu dans la console:

Avec un tuple plus complexe:

tup = ((1,2,3), [1,2], "hello", 3.4)
# affichage du premier élément du tuple 
print("premier élément du tuple:", tup[0])
# affichage du troisième élément du tuple 
print("troisième élément du tuple:", tup[2])
# affichage du premier élément du tuple en position 0
print("premier élément du tuple en position 0: ", tup[0][0])
# affichage du deuxième élément de l'objet liste en position 1
print("deuxième élément de l'objet liste en position 1:", tup[1][1])

Voici le rendu dans la console:

• Concaténer deux tuples:
  

L'opérateur + permet de concaténer (rassembler) les éléments de deux tuples. La concaténation associée à l'assignation donne l'illusion que l'on a modifié un tuple, voir l'exemple de code :

tup_1 = (2, 8, 3)
tup_2 = (1,) 
# concaténation des deux tuples et assignation à la variable tup_1 
tup_1 = tup_2 + tup_1   
# Affichage de tup_1
print("l'objet tuple assigné à tup_1 contient:", tup_1 )

Voici le rendu dans la console:

On pourrait croire que l'on a modifié l'objet tuple qui est assigné à tup_1, il n'en est rien, le code assigne la variable tup_1 à un nouvel objet tuple qui est créé par la concaténation entre l'ancien objet tuple assigné à la variable tup_1 soit (2, 8, 3) et l'objet tuple assigné à la variable tup_2 soit (1,). Dit autrement, avec l'assignation tup_1 = tup_2 + tup_1, on change vers quel objet pointe la variable tup_1.

• Parcourir les éléments d'un tuple:
  

  Comment parcourir la séquence tup = (2, 8, 3) ?
  

  Les éléments sont ordonnés et en nombre fini, on utilise le même codage que pour les listes: une boucle "pour i dans la plage nombre d'éléments du tuple avec un pas de 1" soit for i in range(len(tup)) ou une boucle avec itérateur "pour chaque élément e de tup" soit for e in tup :

  Avec boucle for i in range(len(tup)):
  

  tup = (2, 8, 3)
  # parcours des éléments:
  for i in range(len(tup)):   
      # Affichage de l'élément à l'indice i
      print(f"l'objet à l'indice {i} vaut", tup[i] )
  

  Voici le rendu dans la console:
  
  

  Avec boucle for e in tup:
  

  tup = (2, 8, 3)
  # parcours des éléments:
  for e in tup:   
      # Affichage de l'élément e à chaque itération
      print(f"à cette itération l'élément vaut:", e)
  

  Voici le rendu dans la console:
  

  
  

↑ Retour en haut

Les dictionnaires

Un dictionnaire permet de stocker des éléments (tous types d'objets), c'est une structure de données non ordonnée ( les éléments n'ont pas de position indicée), modifiable (mutable: on peut modifier le contenu d'un dictionnaire), et associative (on associe une clé à une valeur). Un dictionnaire est délimité par les caractères { et }.

Exemple:

# objet dictionnaire vide assigné à la variable dico_1:
dico_1 = {}
# objet dictionnaire, qui contient 3 paires de clé:valeur, assigné à la variable dico_2:
dico_2 = {'a': 2, 'b': 8, 'c': 3}

Les clés sont uniques (elles permettent d'accéder aux valeurs), elles sont souvent représentées par des chaines de caractères mais une clé peut être n'importe quel objet de type simple de python ( un nombre, une chaine), une clé ne peut pas être un type construit comme une liste ou un tuple. Les valeurs associées aux clés peuvent être des objets quelconques y compris d'autres dictionnaires.

Manipulation des dictionnaires

• Connaitre le nombre d'éléments: len(…)
  Si la fonction len reçoit en argument un objet dictionnaire, elle renvoie le nombre d'éléments de cet objet ( nombre de paires clé:valeur).
  Exemple:

   d = {'a': 2, 'b': 8, 'c': 3}
   nb = len(d)   # len renvoie 3 ( nb vaudra 3)
  

• Création d'une paire clé-valeur ( ou modification si la clé existe)
  

   d = {'a': 2, 'b': 8, 'c': 3}
   # modification de la valeur de la clé 'a' ( ou "a" c'est pareil)
   d["a"] = 10
  

  Remarque: Ici on écrit "a" ou 'a' parce que la clé est une chaine de caractères ce n'est pas une règle d'écriture de mettre la clé entre apostrophes.

   d = {'a': 2, 'b': 8, 'c': 3}
   # modification de la valeur de la clé 'a' ( ou "a" c'est pareil)
   d["a"] = 10
   # ajout d'une paire clé:valeur dont la clé n'est pas une chaine de caractères
   d[7] = 8  # ajout de la paire clé:valeur 7:8
   print(d)
  

  Voici le rendu dans la console:
  
  

• Connaitre les clés du dictionnaire (méthode keys())
  Cette méthode appliquée à un objet dictionnaire renvoie toutes ses clés dans une liste (ou un objet dict_keys ce qui se comporte et se manipule comme une liste)

  d = {'a': 2, 'b': 8, 'c': 3}
  # modification de la valeur de la clé 'a' ( ou "a" c'est pareil)
  d["a"] = 10
  # ajout d'une paire clé:valeur dont la clé n'est pas une chaine de caractères
  d[7] = 8  # ajout de la paire clé:valeur 7:8
  # affichage des clés du dictionnaire d
  print(d.keys())
  

  Rendu dans la console:
  

• Connaitre les valeurs des clés du dictionnaire (méthode values())

  Cette méthode appliquée à un objet dictionnaire renvoie toutes les valeurs des clés dans une liste ( ou un objet dict_values ce qui se comporte et se manipule comme une liste).

  d = {'a': 2, 'b': 8, 'c': 3}
  # modification de la valeur de la clé 'a' ( ou "a" c'est pareil)
  d["a"] = 10
  # ajout d'une paire clé:valeur dont la clé n'est pas une chaine de caractères
  d[7] = 8  # ajout de la paire clé:valeur 7:8
  # affichage des valeurs du dictionnaire d
  print(d.values())
  

  Rendu dans la console:
  
  

• Connaitre les valeurs des clés et valeurs du dictionnaire (méthode items())

  Cette méthode appliquée à un objet dictionnaire renvoie toutes les clés et valeurs dans une liste de tuples ( ou un objet dict_items ce qui se comporte et se manipule comme une liste de tuples)

  d = {'a': 2, 'b': 8, 'c': 3}
  # modification de la valeur de la clé 'a' ( ou "a" c'est pareil)
  d["a"] = 10
  # ajout d'une paire clé:valeur dont la clé n'est pas une chaine de caractères
  d[7] = 8  # ajout de la paire clé:valeur 7:8
  # affichage des clés et valeurs du dictionnaire d
  print(d.items())
  

  Rendu dans la console:
  
  

• Parcours d'un dictionnaire

  Un dictionnaire n'est pas ordonné; il se parcourt forcément avec un itérateur:

  "pour chaque élément e de ..." soit for e in…
  

  Important: si on cite un objet dictionnaire après le mot clé in , on sous entend ses clés:
  for e in d: est équivalent à for e in d.keys():
  ce qui donnera ici for e in ['a', 'b', 'c', 7] et permet de comprendre ce que vaudra e à chaque itération (chaque clé).

  d = {'a': 10, 'b': 8, 'c': 3, 7:8}
  # affichage des clés en parcourant le dictionnaire
  for e in d:  
     print(e)
  

  Rendu dans la console:
  
  

• Parcours des clés et valeurs d'un dictionnaire

  On demande "pour clé, valeur dans dictionnaire.items()" soit le code:
  for c,v in d.items():
  pour le dictionnaire d, c'est équivalent ici à:
  

  for c,v in [('a', 10), ('b', 2), ('c', 11), (7, 8)]
  

  d = {'a': 10, 'b': 2, 'c': 3, 7: 8}
  for c,v in d.items():
      print(f" à cette itération c vaut {c} et v vaut {v}")
  

  Rendu dans la console:
  

  
  

• Supprimer une paire clé et valeur d'un dictionnaire

  On peut utiliser la méthode pop(argument) qui renvoie la valeur associée à la clé passée en argument et supprime la paire clé:valeur du dictionnaire:

      d = {'a': 10, 'b': 2, 'c': 11, 7: 8}
      # supprime et renvoie la valeur de la clé 'a'
      x = d.pop("a") # renvoie 10 puis supprime 'a': 10
      print(x)  # affiche 10
  

  On peut aussi supprimer avec del dictionnaire[clé]. del supprime la paire clé:valeur de dictionnaire. Exemple:

      d = {'a': 10, 'b': 2, 'c': 11, 7: 8}
      # supprime la paire clé: valeur  'b':2
      del d['b'] 
      print(d)  
  

  Le résultat de ce code:
  
  
  

• Création d'un dictionnaire par compréhension

  On veut le dictionnaire suivant {0:0, 1:1, 2:4, 3:9, 4:16} assigné à la variable d. De manière classique, on coderait:
  

  d = {}
  for x in range(5):
      dico [x] = x*x 
  

  Par compréhension, on peut coder:

  d = {x: x*x for x in range(5)}
  

  Autre exemple: on veut le dico suivant {0: 0, 2: 4, 4: 16, 6: 36, 8: 64} assigné à la variable d, de manière classique, on coderait:
  

  d = {}
  for x in range(10):
      # si le reste de la division par 2 est 0 ( nombre pair)
      if x % 2 == 0:
          d [x] = x*x 
  

  Par compréhension, on peut coder:

  d = {x: x*x for x in range(10) if x % 2 == 0}
  

↑ Retour en haut