Cours programmation Python pdf

Cours Python Introduction

Télécharger PDF

Cours Python

Introduction

C’est quoi Python ?

• Python a été créé en 1989 par Guido van Rossum, première version publique en 1991.
• La dernière version de Python est la version 3.10.
• L'association "Python Software Foundation" organise le développement de Python.

Caractéristiques de Python

• Multiplateforme: sur de nombreux systèmes d’exploitation.
• Langage de haut niveau (connaissance sur le fonctionnement de l’ordinateur).
• Un script Python n’a pas besoin d’être compilé pour être exécuté, contrairement à des langages comme C++.
• Chaque ligne de code est lue puis interprétée afin que l’ordinateur puisse l’exécuter.
• Orienté objet.
• L’extension de fichier standard des scripts Python est .py.
• Gratuit.
• Langage interprété.
• Deux démarches: procédurale et orientée objet.

Avantages du langage Python

• Langage de haut niveau.
• Langage d’assemblage.
• Fortran, C, Pascal.
• Langage totalement orienté objet.
• Extension de plusieurs librairies qui permettent de gérer des structures de données.
• Langages de script.
• Python renferme des structures de données de haut niveau intégrées au langage, ce qui le rend simple à utiliser.
• Code machine.
• C++, JAVA.
• Perl, Python.
• Shell.
• Un Shell est un interpréteur de commandes interactif permettant d’interagir avec l’ordinateur.
• On utilisera le shell pour lancer l’interpréteur Python.

Mode d’exécution

• Utilisation interactive de l’interpréteur Python.
• Lorsque l’on utilise l’interpréteur en mode interactif, une invite apparaît: l’interpréteur attend les instructions et les exécute quand vous appuyez sur la touche entrée.

Exemple:

>>> 5+3
8

Premier programme

L’interpréteur présente vite des limites lorsqu’on veut exécuter une suite d’instructions plus complexe. Il est donc préférable d’enregistrer ces instructions dans un fichier script (ou programme) Python. Ce script est exécuté autant de fois que l’on veut.

Étapes:

• Ouvrez un éditeur de texte.
• Entrez le code suivant:

print("Hello world!")

Enregistrez votre fichier sous le nom test.py. Vous devriez obtenir un résultat similaire:

python test.py
Hello world!

Commentaires

Tout ce qui suit le caractère # est considéré comme un commentaire.

Exemple:

#---------------
# voici un commentaire
#---------------------

Les variables

Définition

Variable: zone de la mémoire de l’ordinateur à laquelle une valeur est stockée.

En Python:

Déclaration d’une variable est son initialisation.

>>> x=2
>>> x
2

En réalité, il s’est passé plusieurs choses:

• Python a « deviné » que la variable x est un entier.
• Python a alloué (réservé) l’espace pour y accueillir un entier.
• Enfin, Python a assigné la valeur 2 à la variable x.

Remarque:

Dans d’autres langages (en C par exemple), il faut coder ces différentes étapes. En Python, étant un langage dit de haut niveau, une simple instruction x = 2 a suffi à réaliser ces étapes en une fois !

Les variables: Nommage

Le nom des variables en Python :

• Constitué de lettres minuscules (a à z), de lettres majuscules (A à Z), de nombres (0 à 9) ou du caractère underscore (_).
• On ne peut pas utiliser d’espace dans un nom de variable.
• On ne doit pas débuter par un chiffre.
• Éviter d’utiliser un mot « réservé » par Python (print, range, for, from, etc.).
• Sensible à la casse, ce qui signifie que les variables x et X sont différentes.

Les variables: Types

Les types de variables :

• Les entiers (integer ou int).
• Les nombres décimaux que nous appelons floats.
• Les chaînes de caractères (string ou str).
• Les booléens.
• Les nombres complexes, etc.

Exemples de déclaration de variables:

>>> y=3.14
>>> y
3.14
>>> ch = 'bonjour'
>>> ch
'Bonjour'
>>> c="salut"
>>> c
'salut'
>>> a= """loulou"""
>>> a
'loulou'
>>> a= '''lili'''
>>> a
'lili'

Les variables: Les opérations

Opérations sur les types numériques

Les quatre opérations arithmétiques de base se font de manière simple sur les types numériques (nombres entiers et floats) : ‘-’, ‘+’, ‘*’, ‘/’.

Si vous mélangez les types entiers et floats, le résultat est renvoyé comme un float (type plus général).

Par ailleurs, l’utilisation de parenthèses permet de gérer les priorités.

Exemple:

>>> x = 5
>>> y = 3
>>> x + y
8
>>> x - y
2
>>> x * y
15
>>> x / y
2.5
>>> (x * 10) + y
53

Remarque:

L’opérateur / effectue une division. Contrairement aux opérateurs +, - et *, celui-ci renvoie systématiquement un float.

Exemple:

>>> x = 45
>>> y = 2
>>> x / y
22.5

Le type Bool

Valeurs booléennes : False et True.

Les opérateurs de base sont ‘not’, ‘and’, ‘or’.

Les opérateurs de comparaison entre valeurs comparables produisent un type booléen :

• == (égalité)
• != (différent)
• >, >=, <, <= (comparaison)

Type complexe

Les complexes sont écrits en notation cartésienne formée de deux flottants. La partie imaginaire est suffixée par j.

Exemple:

>>> 1j
1j
>>> (2+3j)+(4-7j)
(6-4j)
>>> (9+5j).real
9.0
>>> (9+5j).imag
5.0
>>> (abs(3+4j)) # module de complexe
5.0

Affectation

On affecte une valeur à une variable en utilisant le signe d’égalité (=).

Exemple:

>>> a=2
>>> e=a=2
>>> b = 'john Deuf'
'john Deuf'
>>> b
>>> a=3*7
>>> a
21
>>> b=2*2
4
>>> a=b+5
>>> a
9

Affectation: Variantes d’affectation

Outre l’affectation simple, on peut utiliser les formes suivantes:

Exemple:

>>> e, f = 2.7, 5.1
>>> e, f
(2.7, 5.1)
>>> a, b = a+2, a*2
>>> a = 3
>>> a, b
(5, 6)
>>> v = 4
>>> v += 2
>>> v
6
>>> c = d = 8
>>> c, d
(8, 8)

Affectation: Opérateurs d’affectation +=, -=, *=, /=

Exemple:

>>> x = 5
# Équivaut à x = x ** 2.
>>> x **= 2
>>> x
25
>>> x %= 3
>>> x
1
>>> x //= 2
>>> x
0

Remarque:

Contrairement à C++, Python ne renferme pas les opérateurs d’affectation +=, -=, *=, /=.

La fonction type() vous rappelle le type d’une variable.

Exemple:

>>> x = 2
>>> type(x)

>>> y = 2.0
>>> type(y)

>>> z = '2'
>>> type(z)

Affectations multiples et parallèles

Affectation parallèle

>>> x, y, r = 1.0, 0.5, 12
>>> x, y, z = x + y, x - y, 25
>>> x, y = 10, 20
>>> print(x, y)
10 20
>>> x, y = y, x
20 10
>>> print(x, y, r)
1.0 0.5 12
>>> x = y = 0
0 0 12
>>> print(x, y, z)
15.0 -5.0 25

Saisie de données au clavier

La fonction input

Les valeurs sont stockées dans des variables dont le type correspond à celui des données entrées.

Exemple:

>>> print("Entrez un entier positif :")
>>> n = int(input())
>>> print("Deux puissance ", n, " donne comme résultat : ", 2**n)
Deux puissance 5 donne comme résultat : 32

La fonction input a au plus un seul paramètre: une chaîne de caractères, un message explicatif destiné à l’utilisateur.

Exemple:

>>> nom = input("Entrez votre nom :")
>>> print(nom)

La chaîne de caractères est entrée entre des apostrophes.

Fonction print() : affichage de l’argument passé entre parenthèses

L’argument « end » : utilisé pour la suppression de retour en ligne.

Exemple:

>>> print("Hello world !")
Hello world !
>>> print("Hello world !", end="")
Hello world !
>>> print("Hello "); print("Joe ")
Hello
Joe
>>> print("Hello ", end=""); print("Joe ")
Hello Joe

Affichage de la valeur d’une variable

Possibilité d’afficher le contenu de plusieurs variables en les séparant par des virgules :

Exemple:

>>> nom = "John"
>>> x = 32
>>> print(nom, " a ", x, " ans ")
John a 32 ans

Affichage formaté

La méthode .format() permet une meilleure organisation de l’affichage.

Exemple:

>>> x = 32
>>> nom = "John"
>>> print("{} a {} ans".format(nom, x))
John a 32 ans
>>> chaine = "{2}{0}{1}".format("zero", "un", "deux")
>>> print(chaine)
deuxzeroun
>>> print("je m’appelle {}".format("Bob"))
je m’appelle Bob

Les chaînes de caractères: Type « string »

Une chaîne de caractères délimitée par des apostrophes ou des guillemets.

Exemple:

>>> mot1 = "C'est un test"
>>> mot2 = 'pour les chaînes de caractères.'
>>> print(mot1, mot2)
C'est un test pour les chaînes de caractères.

Remarque:

• Le caractère spécial « \ » permet d’écrire une commande spéciale.
• Il permet d’insérer un certain nombre de caractères spéciaux à l’intérieur d’une chaîne de caractères.
• « \’ » permet d’insérer une apostrophe dans une chaîne délimitée par des apostrophes.
• « \ » permet d’insérer un guillemet dans une chaîne délimitée par des guillemets.

Exemple:

>>> mot = 'C\'est Lundi. Bonne "Début de semaine."'
>>> print(mot)
C'est Lundi. Bonne "Début de semaine."

Les chaînes de caractères: Type « string »

Accès aux caractères d’une chaîne

Le premier caractère est en position 0.

Exemple:

>>> mot = "apprendre"
>>> print(mot[3], mot[4], mot[5], mot[6])
r e n d

Concaténation de chaînes à l’aide de l’opérateur +

Exemple:

>>> mot = "apprend"
>>> print(mot[3] + mot[4] + mot[5] + mot[6])
rendre
>>> mot = mot + "re"
>>> print(mot)
apprendre

Répétition de chaînes à l’aide de l’opérateur *

Exemple:

>>> mot = "cher" * 2
>>> print(mot)
chercher

Longueur d’une chaîne

Exemple:

>>> mot = "apprendre"
>>> print(len(mot))
9

Convertir une chaîne qui représente un nombre en un nombre

Exemple:

>>> m = "12.3"
>>> n = '13'
>>> print(float(m) + int(n))
25.3

Les chaînes de caractères: Type « string »

Possibilité d’ajout des variables dans une chaîne. Pour cela, il faut ajouter les balises suivantes:

• « %s » : Pour ajouter un string.
• « %i » : Pour ajouter un nombre entier.
• « %.5f » : Pour ajouter un nombre à virgule (ici, nombre de décimales voulues).

Exemple:

>>> pi = 3.14
>>> nom = "pi"
>>> sortie = "la valeur de %s est %f mais on peut l’arrondir"
>>> print(sortie % (nom, pi))
la valeur de pi est 3.140000 mais on peut l’arrondir

Les chaînes de caractères: Type « string »

Les commandes suivantes peuvent être utilisées pour les séquences d’échappement:

• « \a » : sonnerie (bip)
• « \b » : retour arrière
• « \n » : saut de ligne
• « \t » : tabulation horizontale
• « \v » : tabulation verticale
• « \r » : retour en début de ligne
• « \ » : saut de ligne
• « \’ » : apostrophe
• « \f » : saut de page
• « \\ » : antislash
• « \ » » : guillemet

Mots réservés

Les 28 mots réservés ci-dessous ne peuvent être utilisés comme noms de variables. Vous devez saisir les majuscules et les minuscules exactes.

• and
• as
• assert
• break
• class
• continue
• def
• del
• elif
• else
• except
• False
• finally
• for
• from
• global
• if
• import
• in
• is
• lambda
• None
• nonlocal
• not
• or
• pass
• raise
• return
• True
• try
• while
• with
• yield

Exercices d’applications

Prédire le résultat : opérations

Essayez de prédire le résultat de chacune des instructions suivantes dans l’interpréteur Python :

Exemple:

>>> ("Pa" + "La") * 2
'PaLaPaLa'
>>> (1 + 2) ** 3
27
>>> "Da" * 4
'DaDaDaDa'
>>> "Da" + 3
TypeError: can only concatenate str (not "int") to str
>>> ("Da" * 4) / 2
TypeError: unsupported operand type(s) for /: 'str' and 'int'
>>> 5 // 2
2
>>> 5 % 2
1
>>> 5 / 2
2.5

Conditions

Dans un programme, les conditions permettent de faire des choix dépendants des différentes situations que l’on peut retrouver dans notre programme.

Exemple:

age = int(input("quel age avez-vous?\n>>>"))
if age >= 18:
    print("vous etes majeur!")

Exemple avec plusieurs conditions:

age1 = int(input("Donner votre age:\n>>>"))
age2 = int(input("Donner l'age de votre voisin:\n>>>"))
if age1 > age2:
    print("vous etes le plus vieux!")
elif age1 < age2:
    print("vous etes le plus jeune")
else:
    print("vous avez le meme age")

Remarque:

Le « if » doit toujours être placé en premier, suivi éventuellement par des « elif » et enfin par un « else » (optionnel) à la fin. Les instructions nécessaires sont alignées.

Conditions : Exercice

Le but de l’exercice est de créer un programme qui renseigne la puissance souscrite. Le programme donnera le prix de l’abonnement en fonction de la puissance souscrite.

Exemple:

Puissance souscrite (€TTC/mois) 
Prix du kWh 
15,55 
14,67 
14,83 
14,83 
14,83
Abonnement 
(€TTC/mois) (kVA) 
5,743
8,926
10,429
11,9612
13,5015

Les boucles

Les boucles sont très importantes en programmation. Elles permettent de répéter des instructions un nombre de fois à l’avance.

Les boucles : While

Les instructions sont répétées tant que la condition d’entrée est vraie (True). Les instructions présentes dans la boucle doivent être décalées d’un alinéa par rapport à l’initialisation de la boucle.

Exemple:

i = 0
while i < 5:
    print(i)
    i += 1

Remarque:

Ce genre de boucle peut entraîner des boucles infinies !

Les boucles : For

La boucle for permet de parcourir une liste et de renvoyer les valeurs de la liste dans une variable de boucle.

Exemple:

for i in range(5):
    print(i)

Remarque:

On peut utiliser l’outil range avec la boucle for. Cela permet de parcourir une liste d’entiers. La fonction range détermine à l’avance combien de fois on veut répéter la boucle.

Exemple:

>>> for i in range(1, 9, 1):
    print(i)
1
2
3
4
5
6
7
8
>>> for i in range(1, 9, 2):
    print(i)
1
3
5
7
>>> for i in range(5):
    print(i)
0
1
2
3
4

Les listes

Liste : structure de données qui contient une série de valeurs.

• Contient des valeurs de types différents (par exemple entier et chaîne de caractères).
• Déclarée par une série de valeurs séparées par des virgules, et le tout entre crochets.

Exemple:

>>> voiture = ['fiat', 'suzuki', 'golf']
>>> notes = [14, 12.5, 10]
>>> mixte = [14, 'fiat', 12.5, 'golf']
>>> voiture
['fiat', 'suzuki', 'golf']
>>> notes
[14, 12.5, 10]
>>> mixte
[14, 'fiat', 12.5, 'golf']

Remarque:

Lorsque l’on affiche une liste, Python la restitue telle qu’elle est.

Les listes

Avantages:

Appeler ses éléments par leur position: indice (ou index) de la liste.

• ‘Indice ‘ : commence à 0 et se termine à n-1.

Exemple:

>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> animaux[0]
'girafe'
>>> animaux[1]
'tigre'
>>> animaux[3]
'souris'
>>> animaux[-3]
'tigre'
>>> animaux[-1]
'souris'

Les listes

Opérations sur les listes

Une liste supporte l’opérateur + de concaténation et l’opérateur * pour la répétition.

Exemple:

>>> ani1 = ['girafe', 'tigre']
>>> ani2 = ['singe', 'souris']
>>> ani2 + ani1
['singe', 'souris', 'girafe', 'tigre']
>>> ani1 * 3
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']

La méthode .append() : ajoute un élément à la fin de la liste.

Exemple:

>>> x = []
>>> x.append(15)
>>> x.append(-2)
>>> x
[15, -2]

La méthode .remove(‘valeur’): supprime un élément à partir de sa valeur.

La méthode .insert(indice, ‘valeur’): insère un élément à un endroit déterminé.

La méthode sort() pour trier une liste.

Exemple:

>>> x = [3, 2, 1]
>>> x.sort()
>>> x
[1, 2, 3]

Les listes: Modification d'une liste

Exemple:

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]

Dictionnaire

Conteneur associatif.

Exemple:

>>> d = {1: '1', 3: '3', 2: '2'} # instancier un dictionnaire
>>> d
{1: '1', 2: '2', 3: '3'}
>>> 1 in d # test d'appartenance
True
>>> d[4] = '4' # insérer un élément
>>> d
{1: '1', 2: '2', 3: '3', 4: '4'}

Exemple de suppression d’un élément:

>>> del d[2]
>>> d
{1: '1', 3: '3', 4: '4'}

Exemple de récupération des clés, valeurs et couples:

>>> d.keys() # retourne la liste des clés
[1, 3, 4]
>>> d.values() # retourne la liste des valeurs
['1', '3', '4']
>>> d.items() # retourne la liste des couples (clé, valeur)
[(1, '1'), (3, '3'), (4, '4')]

Exemple de récupération d’une valeur avec une clé erronée:

>>> d.get(6) # retourne None
>>> d.get(4) # ou la valeur si la clé est correcte
'4'

Exemple d’itération sur les couples d’items:

>>> for k, v in d.items():
    print(k, v)
1 1
3 3
4 4

Exemple de liste ordonnée des clés:

>>> sorted(d.keys())
[1, 2, 3]

Exemple de réinitialisation du dictionnaire:

>>> d.clear()
>>> d
{}

Liste de dictionnaires

La création d’une liste de dictionnaires qui possèdent les mêmes clés permet de créer une structure qui ressemble à une base de données.

Exemple:

# dictionnaire 1
ani1 = {}
ani1["nom"] = "girafe"
ani1["taille"] = 5.0
ani1["poid"] = 1100
ani1
{'nom': 'girafe', 'taille': 5.0, 'poid': 1100}

# dictionnaire 2
ani2 = {'nom': 'signe', 'poid': 70, 'taille': 2}
ani2
{'nom': 'signe', 'poid': 70, 'taille': 2}

# liste des deux dictionnaires
animaux = [ani1, ani2]
animaux
[{'nom': 'girafe', 'taille': 5.0, 'poid': 1100}, {'nom': 'signe', 'poid': 70, 'taille': 2}]

for ani in animaux:
    print(ani['nom'])
girafe
signe

Les tuples

Les tuples (« n-uplets » en français) correspondent aux listes à la différence qu’ils sont non modifiables.

Les listes pouvaient être modifiées par références, notamment lors de l’utilisation de méthodes comme append() ou remove().

Les tuples s’affranchissent de ce problème puisqu’ils sont non modifiables.

Exemple:

>>> x = (1, 2, 3)
>>> x
(1, 2, 3)
>>> x[0:2]
(1, 2)
>>> x[2] = 15
TypeError: 'tuple' object does not support item assignment
>>> x + (2,)
(1, 2, 3, 2)

Les fonctions

Fonction: Morceau de code que l’on peut appeler à différents moments dans une autre partie du programme.

Remarque:

Lorsque l’on a un nombre important de fonctions, il est possible de les regrouper dans des modules.

Les fonctions

But : Pouvoir être appelée à différents moments dans le programme sans avoir à répéter les instructions.

Les fonctions

Une fonction peut également utiliser des données d’entrée (paramètres) et renvoyer des résultats.

Les fonctions

Il est possible de donner des valeurs par défaut aux paramètres. Ceux-ci prendront alors la valeur indiquée si aucune valeur ne leur est appliquée.

Fonctions : Exercice

Créer une fonction qui prend un argument (nombre) et qui renvoie:

• True si le nombre est premier.
• False si le nombre n’est pas premier.

Les modules

Module: un fichier .py qui contient un ensemble de fonctions et variables.

• Le contenu peut être importé et utilisé dans le programme principal ou un autre programme.
• Le mot clé import permet d’importer un module.
• C’est un pas vers la modularité: maximise la réutilisation et facilite le partage du code.
• Il y’a des modules standards prêts à l’emploi sous Python: Ex: random, math, os etc..
• Visibles dans le répertoire « Lib » de python.

Les modules

Création d’un module personnalisé:

• Créer un fichier tva.py.
• Implémenter les fonctions:

def pttc_reduit():
    return # taxe à 20%

def pttc_normal():
    return # taxe à 5.5%

def pttc_alimentaire():
    return # taxe à 10%

Appel des fonctions des modules:

import tva
pht = int(input('prix : '))
pttc = tva.pttc_normal(pht)
print(pttc)

Les modules

Documentation module

Pour obtenir de la documentation sur un module, utilisez la fonction help().

Exemple:

>>> help(math)

FAQ

Qu'est-ce que Python ?

Python est un langage de programmation créé en 1989 par Guido van Rossum. Il est multiplateforme, de haut niveau, orienté objet, et gratuit.

Quelles sont les caractéristiques de Python ?

Python est multiplateforme, de haut niveau, orienté objet, et gratuit. Il est interprété et supporte les démarches procédurale et orientée objet.

Comment déclarer une variable en Python ?

En Python, la déclaration d’une variable est son initialisation. Par exemple, x = 2.