Exercices pour Débutants#

Veuillez noter que ma réponse ne vise pas à remplacer la documentation officielle de Python, mais plutôt à vous fournir les informations nécessaires pour commencer votre projet. La meilleure ressource pour apprendre Python est la documentation officielle de Python, que vous pouvez consulter en cliquant ici. Cette documentation couvre tous les aspects du langage Python, de la syntaxe de base aux fonctionnalités avancées. Vous y trouverez des exemples de code, des guides de référence et des tutoriels pour vous aider à apprendre Python. Voici quelques étapes générales pour démarrer votre projet Python :

Installez Python : Assurez-vous d’avoir Python installé sur votre système. Vous pouvez vérifier la version de Python en exécutant la commande python –version dans votre terminal.
Définissez les objectifs du projet : Identifiez clairement les objectifs et les fonctionnalités que vous souhaitez implémenter dans votre projet.
Créez un environnement virtuel : Pour isoler votre projet Python et ses dépendances, il est recommandé de créer un environnement virtuel. Vous pouvez utiliser des outils tels que virtualenv ou venv pour créer un environnement virtuel, comme expliqué précédemment.
Installez les dépendances : Utilisez l’outil de gestion de paquets Python, pip, pour installer les dépendances nécessaires à votre projet. Vous pouvez spécifier les dépendances dans un fichier requirements.txt pour faciliter l’installation.
Écrivez votre code : Commencez à écrire votre code Python en suivant les bonnes pratiques de codage. Organisez votre code en modules et utilisez des fonctions et des classes pour gérer la logique de votre application.
Testez votre code : Écrivez des tests pour vérifier que votre code fonctionne correctement. Les frameworks de test comme unittest ou pytest peuvent être utilisés pour cela.
Déployez votre application : Selon les besoins de votre projet, vous pouvez déployer votre application Python sur un serveur, créer des packages d’installation ou créer des interfaces utilisateur.

Premiers pas avec Python#

Interaction avec l’interpréteur#

Dans cet exercice, vous allez apprendre à lancer l’interpréteur de Python, à exécuter des commandes simples, et à quitter la console. Pour cela, vous aurez besoin d’avoir Python installé sur votre ordinateur. À la fin de l’exercice, vous serez capable de :

lancer python
quitter python

Ouvrez un terminal et tapez la commande python.
Observez le message qui s’affiche à l’écran.

$ python
Python 3.9.2 (default, Feb 28 2021, 17:03:44)
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.

Tapez quelques commandes Python comme print("Bonjour") ou 2 + 3.

Python 3.9.2 (default, Feb 28 2021, 17:03:44)
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 + 3

Résultat

Notons que la somme de deux entiers est un entier.

Pour quitter la console, tapez la fonction exit() ou quit().

>>> exit()
$

Utilisons Python comme une calculatrice. Notons qu’à la fin de chaque ligne, nous appuyons sur la touche “Entrée”.

Félicitations 👍 Nous savons maintenant utiliser Python comme une calculatrice.

L’importance des tabulations et espaces#

Les tabulations est espaces ont un rôle important dans python. Les tabulations (ou indentations) servent à délimiter le corps des fonctions ou les blocs de code tandis que les espaces servent à

En respectant les espaces et les tabulations, vous pouvez rendre votre code Python plus facile à lire et à comprendre pour vous-même et pour les autres développeurs.

L’exemple suivant introduit plusieurs notions. Nous focaliserons sur les tabulations et les espaces.

def calculate_average(numbers:list) -> float:
    """
    Calcule la moyenne de plusieurs nombres
    """

    total = 0
    count = 0
    for num in numbers:
        total += num
        count += 1
    average = total / count
    return average

numbers = [1, 2, 3, 4, 5]
result = calculate_average(numbers)
print("La moyenne est :", result)

L’indentation est utilisée pour délimiter les blocs de code. Par exemple, l’indentation des lignes 2 à 9 indique que ces lignes font partie du corps de la fonction calculate_average. De même, l’indentation de la ligne 11 indique que cette ligne fait partie du corps du programme principal.
Les espaces avant et après l’opérateur d’addition (+=) indiquent les opérations à effectuer. Par exemple, la ligne total += num ajoute la valeur de num à total.
Les espaces entre les arguments des appels de fonction, par exemple dans calculate_average`(numbers) et print(« La moyenne est : », `result`), améliorent la lisibilité du code.

Il arrive parfois (?) que l’on fasse des erreurs d’indentation. L’interpreteur les repère et vous les signale. Repérez bien ce message d’erreur.

$ python
Python 3.9.2 (default, Feb 28 2021, 17:03:44)
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>     print('Hello')
File "<stdin>", line 1
    print('Hello')
IndentationError: unexpected indent
>>>

Les variables#

Python ne permet pas le typage d’une variable ce qui a certains avantages (pas de spécification, pas d’erreur de typage, etc.) et certains inconvénients (multiplier des choux par des carottes) Pour affecter une variable, on utilise l’opérateur “\(=\)”. Pour afficher une variable, on utilise la fonction print().

>>> x = 3435    # Affectation du nombre 3435 à x
>>> print(x)
>>> 3435
>>> x = '3435'  # Affectation du texte '3435' à x
>>> print(x)
>>> 3435
>>> x = y = 12  # Affectation de 12 à x et y
>>> print(x,y)
>>> 12 12
>>> y = 2*x     # Calcul de y en fonction de x
>>> print(x,y)
>>> 12 24

Il peut arriver que l’on ait besoin de saisir dynamiquement une variable.

>>> x = input('Saisir la valeur\n')    # Affectation du nombre 3435 à x
Saisir la valeur
22
>>> x
'22'

Les types de données#

La gestion des nombres#

>>> 2                   # Entier
2
>>> 2.                  # Flottant
2.0
>>> 2e3                 # 2000
2000.0
>>> 6.022_140_76e23     # Nombre d'avogadro (les milliers sont séparés par des _ pour améliorer la lisibilité)
6.02214076e+23

Les opérateurs mathématiques#

>>> 25 / 3          # Division traditionnelle
8.333333333333334
>>> 25 // 3         # Partie entière de la division
8
>>> 25 % 3          # Reste de la division. On parle aussi de modulo
1
>>> 2**8            # 2 à la puissance 8
256
>>> 3*5 == 15       # Opérateur de comparaison. Retourne True si vrai sinon False
True

Les fonctions mathématiques#

>>> round(3.1416,2) # Arrondi d'un flottant à 2 chiffres après la virgule
3.14
>>> min(12,7.0,3)   # Minimum de plusieurs chiffres
3
>>> max(12,7.0,3)   # Maximum de plusieurs chiffres
12

Les fonctions de conversion#

>>> int(12/3)       # Conversion d'un flottant en entier
4
>>> float(3+2)      # Conversion d'un n-entier en flottant
5.0
>>> type(1.414)     # Nature du nombre
<class 'float'>
>>> bin(5)          # Conversion d'un entier en binaire
0b101
>>> format(5,'b')   # Conversion d'un entier en binaire

Note

Notons que l’on n’a pas utilisé de fonctions « complexes ». Ce sera l’objet d’une autre leçon.

La gestion du texte#

>>> 'Bonjour'           # Affichage d'un texte avec simple quote
'Bonjour'
>>> "Bonjour"           # Affichage d'un texte avec double quote
'Bonjour'
>>> "N'hésitez pas à faire des commentaires"            # Une simple quote entre deux doubles quotes
"N'hésitez pas à faire des commentaires"
>>> 'N\'hésitez pas à faire des commentaires'           # Une simple quote "echappée" entre deux simples quotes
"N'hésitez pas à faire des commentaires"
>>> print('N\'hésitez pas à faire des commentaires')    # Utilisation de la fonction print() pour afficher le résultat calculé.
N'hésitez pas à faire des commentaires
>>> print('Un texte en\ndeux lignes')                   # Utilisation du caractère \n pour sauter de ligne
>>> print('Un text\ttabulé...')                         # Utilisation du caractère \t pour ajouter une tabulation
Un text tabulé...
>>> print('La concaténation'+' '+'de deux textes')      # Concaténation de trois textes
La concaténation de deux textes
>>> print('La somme de 4 + 4 fait', 8)                  # Concaténation d'un texte et d'un nombre. Valable uniquement pour l'affichage
La somme de 4 + 4 fait 8
>>> res = input('Entrez votre nom\n')                   # Entrée d'une valeur en ligne de commande
Entrez votre nom
toto
>>> print(res)                                          # Affichage du contenu de la variable res
toto

Les fonctions de conversion et d’extraction#

>>> str(2)              # Conversion d'un entier en texte
'2'
>>> int('2')            # Conversion d'un texte en entier
2
>>> float('1.414')      # Conversion d'un texte en flottant
1.414
>>> int('1.414')        # Conversion d'un texte en entier. Provoque une erreur car non entier.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1.414'
>>> 'abcdef'[3]         # Retourne le 4ième caractère du texte
d
>>> 'abcdef'[0:2]       # Retourne les 2 premiers caractères
abc
>>> 'abcdef'[-1]        # Retourne la dernère lettre du texte
f
>>> 'abcdef'.index('a')

Les listes#

Les listes sont utilisées pour gérer une énumération homogène ou hétérogène de valeurs.

>>> [1,2,3,5,7,11]          # Liste des premiers nombres premiers
[1, 2, 3, 5, 7, 11]
>>> [10, "Hello", 3.14]     # Liste de valeurs hétérogènes
[10, 'Hello', 3.14]
>>> [ [1,0], [0,-1]]        # Liste de liste / représentation linéaire d'une matrice 2D
[[1, 0], [0, -1]]

Manipuler une liste#

Les valeurs présentes dans une liste peuvent être accédées via un indice. Le permier élément porte l’indice \(\emptyset\).

maListe: [ 'arbre', 'vélo', 'fleur']
indice :      0        1       2

>>> [1,2] + [3,4]                   # Addition de deux listes
[1, 2, 3, 4]
>>> [1,2] + [3,]                    # Ajout d'une valeur
[1, 2, 3]
>>> [1,2] + [3]                     # Ajout d'une valeur
[1, 2, 3]
>>> [1,2].append(3)                 # Ajout d'une valeur
[1, 2, 3]
>>> [1,2,3][:-1]                    # Suppression à l'affichage de la dernière valeur
[1, 2]
>>> [1, 2, 3][1]                    # Accès à la 2ème valeur de la liste
2
>>> [1,2,3][::2]                    # Sélectionne les valeurs dont l'indice est modulo 2
[1, 3]
>>> del a[2]                        # Suppresion de la 3ième valeur
>>> del a[1:4]                      # Suppression des valeurs dont les positions sont entre 1 et 4
>>> x = [1,12,14,5]
>>> x.index(12)                     # Retrouve la position de la valeur 12 dans la liste
2
>>> x.pop(x.index(12))              # Supprime la valeur 12 de la lsite
[1,14,5]

Finalement, on se rend compte que l’accès au contenu d’une liste fonctionne sur le modèle liste[début:fin:pas]

>>> a = [18, 19, 5, 8, 2]
>>> print(a)
[18, 19, 5, 8, 2]
>>> len(a)                          # Longueur de la liste
5
>>> a.sort()                        # Trie la liste en ordre croissant
>>> print(a)
[2, 5, 8, 18, 19]
>>> a.sort(reverse=True)            # Trie la liste en ordre décroissant
[19, 18, 8, 5, 2]
>>> a = 'Hello World'
>>> a.sort()                        # Tente sans succès de trier le texte
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'sort'
>>> a = list(a)                     # Converti le texte en liste de caractères
>>> print(a)
['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
>>> a.sort()                        # Tri une liste de caractères
[' ', 'H', 'W', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r']
>>> set(a)
{'o', 'r', ' ', 'l', 'W', 'H', 'd', 'e'}
>>> b = list(set(a))                # Transforme le set en liste
['o', 'r', ' ', 'l', 'W', 'H', 'd', 'e']
>>> ''.join(b)                      # Fusionne les éléments de la liste avec '' comme séparateur
'or lWHde'

Fonctions associées aux listes#

>>> maListe = list(range(0,10))
>>> min(maListe)
0
>>> max(maListe)
9
>>> sum(maListe)
45

Note

Notons que le texte est géré comme une liste mais n’est pas une liste.

Il est aussi possible d’utiliser les listes comme des piles ou des files. Vous trouverez plus d’information ici.

Les dictionnaires#

Un dictionnaire est une liste d’élément clé/valeur. Chaque valeur pouvant être un entier, un flottant, un texte, une liste ou… un dictionnaire.

>>> mydict = {}                     # Initialisation du dictionnaire
>>> mydict['nom'] = 'France'        # Ajout de la valeur nom
>>> mydict['capitale'] = 'Paris'    # Ajout de la valeur capitale
>>> mydict['codeISO'] = 'FRA'       # Ajout du Code ISO
>>> mydict['FetNat'] = '14 juillet' # Ajout de la valeur Fête nationale
>>> mydict['superficie'] = 672_051  # Ajout de la valeur superficie
>>> mydict['departements'] = ['Ain', 'Aisne']
>>> mydict
{'nom': 'France', 'capitale': 'Paris', 'codeISO': 'FRA', 'FetNat': '14 juillet', 'superficie': 672051, 'departements': ['Ain', 'Aisne']}

On peut accéder à un élément de la liste en utilisant sa clé

>>> mydict['nom']                   # Retourne la valeur nom
'France'
>>> mydict['population']            # Retourne la valeur population
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'population'
>>> mydict.get('nom')               # Retourne la valeur nom
'France'
>>> mydict.get('population')        # Retourne aucune valeur. La clé n'existe pas
>>>
>>> for key in mydict:
...     print(key, mydict(key))
nom France
capitale Paris
codeISO FRA
FetNat 14 juillet
superficie 672051
departements ['Ain', 'Aisne']
>>> mydict.keys()                   # Liste des clés du dictionnaire
dict_keys(['nom', 'capitale', 'codeISO', 'FetNat', 'superficie', 'departements'])
>>> mydict.values()                 # Liste des valeurs du dictionnaire
dict_values(['France', 'Paris', 'FRA', '14 juillet', 672051, ['Ain', 'Aisne']])

On peut trier les données du dictionnaire.

>>> stats= {'e':12.10, 's':6.51, 'a':7.11, 'n':6.39, 'i':6.59 }
>>> sorted(stats)                   # Liste et trie les clés par clé
['a', 'e', 'i', 'n', 's']
>>> sorted(stats,key=stats.get)     # Liste et trie les clés par valeur
['n', 's', 'i', 'a', 'e']