Vous êtes sur la page 1sur 10

C. Manipulation des listes - tableaux - fonctions - conditions ................

1
C.1. Les listes....................................................................................................................................... 1

C.1.1. Opérations de base : création, fonction len() .................................................................................. 2

C.1.2. Calculs avec les listes : addition, multiplication- instruction range() ................................................. 2

C.1.3. Autres opérations : classer, inverser, remplacer ............................................................................. 3

C.2. Les tableaux ................................................................................................................................. 3

C.2.1. Création avec la fonction np.array() - Fonctions np.arange() - np.linspace() .................................. 4

C.2.2. Opérations simples ....................................................................................................................... 5

C.2.3. Opérations avancées utiles dans les programmes en physique-chimie............................................. 5

C.2.4. Convertir une liste en tableau ........................................................................................................ 6

C.3. Créer sa propre fonction ............................................................................................................... 7

C.3.1. Syntaxe et premier exemple .......................................................................................................... 7

C.3.2. L’instruction return ....................................................................................................................... 7

C.3.3. Exercice 2 ..................................................................................................................................... 7

C.4. Conditions et boucles ................................................................................................................... 7

C.4.1. Conditions if – elif – else ................................................................................................................ 8

C.4.2. Boucle while ................................................................................................................................. 8

C.4.3. Les instructions for … in… pour parcourir des séquences ................................................................. 9

C. anipulation des listes - tableaux - fonctions - conditions

C.1. Les listes


C’est une séquence d’entiers int, de chaines de caractères str, de nombres à virgules float, placés entre [ ].

La position d’un élément dans une liste est repérée par son index :

[ 1 ,2 ,3 ,4 ,5 ]
1er élément d’une liste : index 0 index 4 noté aussi -1 (dernier élément)
index 1

Les [ ] servent à délimiter une liste mais aussi à désigner un élément grâce à son index.

Page | 1
C.1.1. Opérations de base : création, fonction len()

C.1.2. Calculs avec les listes : addition, multiplication- instruction range()

L’instruction range(paramètres) permet de générer une liste de nombres dont on fixe les paramètres :

range(min, max exclu, écart) on renseigne : valeur min., max. et l’écart entre elles
range(max exclu) si un seul paramètre est indiqué, il s’agit du max

Page | 2
C.1.3. Autres opérations : classer, inverser, remplacer

C.2. Les tableaux


Page | 3
C.2.1. Création avec la fonction np.array() - Fonctions np.arange() - np.linspace()

Les tableaux permettent des calculs plus rapides qu’avec les listes, mais il est plus long de les modifier.

Les deux seront utiles pour calculer une vitesse par exemple, ou une énergie.

On peut créer son propre tableau ou générer des tableaux d’une ligne avec :

• La fonction np.arange(paramètres) :

np.arange( min , max exclu , écart entre deux valeurs successives)


np.arange(max exclu) par défaut : 0 est la valeur min, écart de 1

• La fonction np.linspace(paramètres) :

np.linspace( min , max inclus , nb de valeurs)

Page | 4
C.2.2. Opérations simples

Les opérations
×÷ − +
appliquées aux TABLEAUX
donnent des résultats
différents de ceux obtenus
avec les LISTES.

nan : not a number.

Erreur (division par 0)

C.2.3. Opérations avancées utiles dans les programmes en physique-chimie

Page | 5
C.2.4. Convertir une liste en tableau

Il est rapide de taper des valeurs sous forme d’une liste mais il est plus facile d’effectuer des calculs sur des tableaux.

Il sera donc utile de convertir une liste en tableau de valeurs.

Page | 6
C.3. Créer sa propre fonction
C’est un sous-programme dans le programme qui pourra être appelé et exécuté plusieurs fois.

C.3.1. Syntaxe et premier exemple

La syntaxe générale doit respecter l’indentation , c’est-à-dire le retour à la ligne avec tabulation :

def nom_fonction(paramètres) :

instruction 1
instruction 2

Il faut ensuite exécuter cette fonction dans l’interpréteur.

L’exemple ci-contre operation(2,3) calcule 22 + 3 et renvoie 7

C.3.2. L’instruction return

Return permet de renvoyer (= stocker) le résultat dans une variable (z dans l’exemple qui suit) :

C.3.3. Exercice 2

Version 1 : créer une fonction « matiere » qui permet de calculer la quantité de matière avec la masse et la masse
molaire comme paramètres et qui utilise l’instruction return. Exécutez cette fonction. Réponses 1

Version 2 : la fonction « mole » doit vous demander la masse et masse molaire et doit vous permettre de
sauvegarder le résultat. Réponse exercice 2 version 1 réponse version 2

C.4. Conditions et boucles

Page | 7
C.4.1. Conditions if – elif – else

if condition : une seule instruction if condition :

instruction1
instruction 2

Les conditions possibles :

𝑥< 𝑦 𝑥 > 𝑦 𝑥 >= 𝑦 𝑥 <= 𝑦 𝑥 == 𝑦 𝑥! = 𝑦 (𝑥 ≠𝑦)

Taper 𝑥 = 𝑦 signifie que vous affectez la valeur y à la variable x.

Taper 𝑥 == 𝑦 signifie que vous testez la condition « est-ce que x est égal à y ? »

EXERCICE 3 : demander une note / 20, si celle-ci est inférieure à 10, alors afficher « vous n’avez pas la moyenne ».

Observer le comportement de votre programme pour une note supérieure ou égale à 10. Réponses 3 - 4 et 5

if condition : instruction 1

else : instruction 2

EXERCICE 4 : reprendre le n°3 en traitant le cas des notes supérieures à 10. Pour 2 conditions : utiliser if elif else

if condition 1 : instruction 1
elif condition 2 : instruction 2

else : instruction 3

EXERCICE 5 : améliorez l’exercice 4 en détaillant les 3 possibilités : note inférieure, supérieure à 10 ou égale.
Cet exercice suppose que l’utilisateur connait les limites des notes entre 0 et 20.

C.4.2. Boucle while

while condition : instruction Pour plus d’une seule instruction, retourner à la ligne avec indentation.

EXERCICE 6 : demander un nombre, tant que ce nombre < à 30, afficher « vous avez perdu ». Réponse exercice 6

EXERCICE 7a : Utiliser une boucle while pour afficher la table de multiplication du 7. Réponse exercice 7a

EXERCICE 7b : améliorez l’exercice 7a en créant une fonction (utilisant la boucle while) capable d’afficher la table de
n’importe quel nombre. Réponse exercice 7b version 2 avec question posée
Page | 8
C.4.3. Les instructions for … in… pour parcourir des séquences

• La boucle while effectue une instruction (ou plusieurs) tant qu’une condition est vraie
• La boucle for parcourt un ensemble d’éléments : par exemple les éléments d’une liste, les lettres d’un mot…

for i in range(0,n) : instruction # parcourt les entiers de 0 à n-1 et exécute une instruction

for lettre in chaine : instruction # parcourt les lettres d’une chaine et instruction

Page | 9
EXERCICE 8a : afficher toutes les lettres du mot « Python » Réponses exercices 8
EXERCICE 8b : afficher toutes éléments de la liste [1, 2, 3, 4, 5, 6, 7]
EXERCICE 8c : afficher tous les entiers compris entre 0 et 10, penser à la fonction range().
EXERCICE 8d : afficher la table de multiplication du 7
EXERCICE 8e : afficher les nombres pairs entre 0 et 20 (aide : penser à la division avec reste nul si nombre pair)

Conclusion : pour parcourir une séquence (liste, chaine de caractère…).

L'instruction for permet donc d'écrire des boucles, dans lesquelles l'itération traite successivement tous les
éléments d'une séquence donnée.

Elle s’applique aux chaines de caractères mais aussi aux listes.

Page | 10

Vous aimerez peut-être aussi