nicot3m

Commencer

Prérequis avant de commencer

Dans ce chapitre, nous allons voir comment installer Python, tester notre première commande et écrire des commentaires.

Environnement

Mon environnement de développement

IDE Thonny ou Pycharm sous Windows 10 avec Python 3.10
J'utilise Thonny pour les projets simples: Lien pour installer Thonny
J'utilise Pycharm Community pour les projets plus complexes nécessitant un environnement virtuel:Lien pour installer Pycharm

Mon premier programme

Hello world

La fonction print

La fonction print affiche du texte dans la console

Elle s'écrit print("mon texte")


>>> print("Hello, world!")
Hello, world!

Les commentaires

Il y a deux moyens pour rajouter des commentaires.

Sur une ligne

On utilise le #

Il s'écrit # mon commentaires

```
> # Une ligne de commentaire
```

Sur plusieurs lignes

On utilise le docstring

Il s'écrit """ mes commentaires """
Un docstring est aussi utilisé en début de programme ou de fonction pour y ajouter une description.


>>> """ 
... Plusieurs lignes
... de commentaires
... """

Aide

La fonction help

Elle s'écrit help(fonction_python).


>>> help(print)
Help on built-in function print in module builtins:
print(*args, sep=' ', end='\n', file=None, flush=False)

Les variables

Dans ce chapitre, nous allons voir l'initialisation, les types de variables, les nombres.

L'affectation

L'affectation permet d'initialiser ou de modifier la valeur d'une variable.

L'initialisation permet d'assigner une valeur pour la première fois à une variable.
La déclaration permet de nommer une variable.
Python permet de déclarer et d'initialiser une variable en même temps.
Pour affecter une valeur à une variable, on renseigne son nom égale sa valeur.

```
>>> age = 44
>>> print(age)
44
```

Les types

Python est un langage à typage fort dynamique.

Un typage fort signifie que les types des données sont strictement appliqués. Il n'est pas possible d'effectuer des opération entre des types de données qui ne sont pas compatibles sans une conversion explicite.

Un typage dynamique signifie que le type d'une variable est déterminé à l'exécution, et non pas à la compilation. Il n'est pas obligatoire de déclarer le type d'une variable explicitement.Cela donne plus de flexibilité car le type d'une variable peut changer.

Le tableau suivant présentes les différents types de variables.

Type	Détail
int	nombres entiers
float	nombres décimaux
bool	booléen True ou False
str	texte
list	liste
tuple	tuple
set	ensemble
dict	dictionnaire

Connaître le type d'une variable

La fonction type permet de connaitre le type d'une variable.

```
>>> type(age) = 44
<class 'int'>
```

Les nombres

Les nombres sont de type int ou float.

Python reconnait automatiquement si c'est un type entier ou float.


>>> prix = 1.35
>>> type(prix)
<class 'float'>

Opérations arythmétiques

Voyons les différentes opérations possibles.

L'addition avec l'opérateur +

```
>>> 2 + 3
5
```

La soustraction avec l'opérateur -

```
>>> 5 - 2
3
```

La multiplication avec l'opérateur *

```
>>> 2 * 3
6
```

La division avec l'opérateur /

```
>>> 3 / 2
1.5
```

Le quotient entier avec l'opérateur //

```
>>> 18 // 4
4
```

Le reste entier avec l'opérateur modulo %

```
>>> 18 % 4
2
```

Les puissances avec l'opérateur **

```
>>> 3 ** 2
9
```

Les puissances de 10avec l'opérateur e

```
>>> 314e-2
3.14
```

Fonctions sur les nombres

Voyons les principales fonctions.

La valeur absolue avec la fonction abs

```
>>> abs(-3)
3
```

Obtenir un nombre entier avec la fonction int

```
>>> int(3.2)
3
```

Obtenir un nombre décimal avec la fonction float

```
>>> float(3)
3.0
```

Calculer la puissance avec la fonction pow

```
>>> pow(3, 2)
9
```

Arrondir un nombre avec la fonction round

```
>>> round(3.14159, 2)
3.14
```

Calculer le quotient entier et reste entier d'un nombre avec la fonction divmod


>>> divmod(18, 4)  # Quotient entier et reste entier
(4, 2)

Les booléens

Un booléen peut prendre la valeur True ou False.

Les booléens sont utilisés dans les tests conditionnels que nous verrons plus loin.


>>> choix = 'True'
>>> print(f"Mon choix a pour valeur {choix}.")
Mon choix a pour valeur True.

Le texte

Le texte est de type string (chaîne de caractères).

C'est une séquence de caractères, entre apostrophes (simple quotes) ' ' ou entre guillements (double quotes) " ".


>>> nom = 'nico'
>>>> print(f"Bonjour {nom}!")
Bonjour nico!

Fonctions sur le texte.

Voyons les quelques fonctions utiles pour traiter le texte.

La fonction str permet de déclarer la variable mon_texte de type string et de convertir un entier en chaine de caractères.


>>> mon_texte = str() 
>>> mon_car = str(3)
>>> print(type(mon_car))

Les caractères spéciaux

Les caractères spéciaux sont précédés du symbole antislash \.

Tabulation avec \t

```
>>> print("a\tb")
a       b
```

Retour à la ligne \n

```
>>> print("a\nb")
a
b
```

Antislash avec \\\

```
>>> print("\\")
\
```

Apostrophe avec \'

```
>>> print('\'') 
'
```

guillemet avec '"

```
>>> print('\"') 
"
```

Les opérateurs

L'opérateur + permet de concaténer 2 chaines de caractères.


>>> chaine1 = "a"
>>> chaine2 = "b"
>>> chaine1 + chaine2
'ab'

Les méthodes

Voyons les méthodes de mise en forme, de conversion, de recherche, de codes UTF-8.

Les méthodes de mise en forme

Les méthodes lower, upper, capitalize, center, strip.

Transformer le texte en minuscule avec la méthode lower

```
>>> 'AB'.lower()
'ab'
```

Transformer le texte en majuscule avecla méthode upper

```
>>> 'ab'.upper()
'AB'
```

Mettre le texte en minuscule et le 1er caractère en majuscule avec la méthode capitalize

```
>>> 'aBcD'.capitalize()
'Abcd'
```

Centrer le texte encadré par n espaces avec la méthode center

```
>>> 'ab'.center(10)
'    ab    '
```

Supprimer les espaces au début et à la fin la méthode strip

```
>>> '    a    b    '.strip()
'a    b'
```

Les méthodes de conversion

Les méthodes split et join.

Convertir un texte en liste avec la méthode split et un séparateur

```
>>> 'a_b'.split('_')
['a', 'b']
```

Convertir une liste en une chaine de caractères avec la méthode join et un séparateur

```
>>> '_'.join(['a', 'b'])
'a_b'
```

Les méthodes de recherche

Les méthodes find, replace, startswith, endswith, islower, isupper, isdigit, isalpha.

Chercher la position d'un 1er caractère entre 2 positions avec la méthode find. Le compte commence à 0.


>>> 'abcdacbdabcda'.find('a', 4, 10)
4

Remplacer les n 1ere occurence d'un caractère par un autre caractère, tous par défaut avec la méthode replace.


>>> 'ababa'.replace('a', 'b', 2)
'bbbba'

Vérifier qu'un texte commence par un caractère avec la méthode startswith.

```
>>> 'ab'.startswith('a')
True
```

Vérifier qu'un texte finit par un caractère avec la méthode endswith.

```
>>> 'ab'.endswith('b')
True
```

Vérifier qu'un texte est uniquement en minuscule avec la méthode islower().

```
>>> 'ab'.islower()
True
```

Vérifier qu'un texte est uniquement en majuscules avec la méthode isupper().

```
>>> 'aB'.isupper()
False
```

Vérifier qu'un texte est composé uniquement de nombres avec la méthode isdigit().

```
>>> '123'.isdigit()
True
```

Vérifier qu'un texte est composé uniquement de lettres avec la méthode isalpha().

```
>>> 'abc'.isalpha()
True
```

Les méthodes des codes UTF-8

Les méthodes ord et chr.

Renvoyer le code UTF-8 d'un caractère avec la méthode ord

```
>>> ord('a')
97
```

Renvoyer le caractère d'un code UTF-8 avec la méthode chr

```
>>> chr(65)
'A'
```

L'écriture formatée

Les f-string


>>> age = 12
... f"J'ai {age} ans."
"J'ai 12 ans."

Les structures de données

Les listes, les tuples, les sets, les dictionnaires.

Séquence: Ensemble fini et ordonné d'éléments indicés de 0 à n-1.

Mutable: Que l'on peut modifier.

Ordonné: Les éléments sont rangés dans un ordre défini.

Les listes

Une liste est une séquence mutable. Elle est donc ordonnée et modifiable.

Création

Les crochets permettent de créer une liste.

```
			
>>> noms = ["nico", "anne", "bob"]
```

Initialisation et conversion

La fonction list() permet de créer une liste vide.

			
>>> noms = list()
>>> print(type(noms))

Elle permet aussi de convertir d'autres types de données en listes.

				
>>> list(range(5))
[0, 1, 2, 3, 4]

Accéder à un élément de la liste avec son index

L'index commence à 0.

```
				
>>> noms[0]
'nico'
```

Les méthodes

Voyons quelques méthodes sur les listes.

Ajouter un élément à la fin de la liste avec la méthode append.

Dans l'exemple suivant, on ajoute 'toto' à noms.


>>> noms.append('toto')
>>> print(noms)
['nico', 'anne', 'bob', 'toto']

Insérer un élément à un index spécifique avec la méthode insert.

Dans l'exemple suivant, on insère 'lisa' dans la liste noms à l'index 3.


>>> noms.insert(3, 'lisa')
>>> print(noms)
['nico', 'anne', 'bob', 'lisa', 'toto']

Insérer une lise à la fin d'une liste avec la méthode extend.

Dans l'exemple suivant, on insère la liste ['louis', 'hugo'] dans la liste noms.


>>> noms.extend(['louis', 'hugo'])
>>> print(noms)
['nico', 'anne', 'bob', 'lisa', 'toto', 'louis', 'hugo']

Supprimer un élément avec la méthode remove.

Dans l'exemple suivant, on supprime la première occurence de 'bob' dans la liste noms.


>>> noms.remove('bob')
>>> print(noms)
['nico', 'anne', 'lisa', 'toto', 'louis', 'hugo']

Supprimer un élément à partir de son index et renvoyer la valeur de l'élément supprimé avec la méthode pop .

Dans l'exemple suivant, on supprime l'élément à l'index 5 dans la liste noms.


>>> noms.pop(5)
'hugo'
>>> print(noms)
['nico', 'anne', 'lisa', 'toto', 'louis']

Il existe aussi la fonction del qui fonctionnent avec l'index entre crochets.

Trier une liste avec la méthode sort

Dans l'exemple suivant, on trie la liste noms par ordre alphabétique.


>>> noms.sort()
>>> print(noms)
['anne', 'lisa', 'louis', 'nico', 'toto']

Trier une liste dans l'ordre décroissant avec la méthode reverse

Dans l'exemple suivant, on trie la liste noms par ordre alphabétique inverse.


>>> noms.reverse()
>>> print(noms)
['toto', 'nico', 'louis', 'lisa', 'anne']

Trouver la position d'un élément dans la liste avec la méthode index

Dans l'exemple suivant, on cherche l'index de la première occurence de lisa dans la liste noms.

```
>>> noms.index('lisa')
3
```

Compter le nombre d'occurences d'un élément avec la méthode count

Dans l'exemple suivant, on cherche le nombre d'occurences de lisa dans la liste noms.

```
>>> noms.count('lisa')
1
```

Copier une liste avec la méthode deepcopy (inclus les objets imbriqués)

Dans l'exemple suivant, on crée la liste noms2 qui est la copie de la liste noms. Les 2 listes sont indépendantes.


>>> noms2 = noms.deepcopy()
>>> print(noms2)
['toto', 'nico', 'louis', 'lisa', 'anne']

Effacer tous les éléments de la liste avec la méthode clear

Dans l'exemple suivant, on vide la liste noms.

```
>>> noms.clear()
>>> print(noms)
[]
```

La compréhension de liste

Elle permet de créer une nouvelle liste en une seule ligne de commande à partir d'une séquence.

Elle s'écrit ma_liste = [expression for element in ma_sequence if condition

Dans l'exemple suivant, on crée la liste pairs.


>>> pairs = [x for x in range(10) if x % 2 ==0]
>>> print(pairs)
[0, 2, 4, 6, 8]

Les tuples

Un tuple est une séquence non mutable. Il est donc ordonné et non modifiable.

Création

Les parenthèses permettent de créer un tuple.
Dans l'exemple suivant, le tuple coordonnees permet de sauver plusieurs valeurs.

```
			
>>> coordonnees = (5, 12) 
```

Initialisation et conversion

La fonction tuple() permet de créer un tuple vide.

			
>>> mon_tuple = tuple()
>>> print(type(mon_tuple))

Elle permet aussi de convertir d'autres types de données en listes.

				
>>> mon_tuple = tuple('hello')
('h', 'e', 'l', 'l', 'o')

Accéder à un élément du tuple avec son index

L'index commence à 0.

				
>>> x = coordonnees[0]
>>> print(x)
5

Retourner plusieurs valeurs dans une fonction

Dans l'exemple suivant, la fonction get_names retourne le prénom et le nom dans un tuple names.

				
>>> def get_names()
...    firstname = input('your firstname: ')
...    lasttname = input('your lastname: ')
...    return firstname, lastname
>>> names = get_names()
your firstname: bob
your lastname: dupont
>>> print(names)
('bob', 'dupont')

Un tuple peut aussi servir à créer les clés d'un dictionnaires.

Les sets

Un set est un ensemble d'éléments. Il est non ordonné et sans doublons.

Création

Les accolades permettent de créer un set.

			
>>> couleurs = {"rouge", "vert", "bleu"}

Initialisation et conversion

La fonction set() permet de créer un ensemble vide.

			
>>> fruits = set()
>>> print(type(fruits))

Elle permet aussi de transformer une liste en set pour ne garder que les valeurs uniques.

				
>>> liste_notes = [12, 8, 15, 8, 17, 12]
>>> set_notes = set(liste_notes)
>>> print(set_notes)
{8, 17, 12, 15}

Les méthodes

Voyons les méthodes add, update, remove, discard.

Ajouter un élément avec la méthode add.

Dans l'exemple suivant on ajouter la note 20 à set_notes.


>>> set_notes.add(20)
>>> print(set_notes)
{8, 12, 15, 17, 20}

Ajouter des éléments avec la méthode update.

Dans l'exemple suivant on ajouter la liste new_notes à set_notes.


>>> new_notes = [4, 16]
>>> set_notes.update(new_notes)
>>> print(set_notes)
{4, 8, 12, 15, 16, 17}

Supprimer un élément avec les méthodes remove ou discard.

Dans l'exemple suivant on ajoute la note 20 à set_notes.

La méthode remove lève une erreur si l'élément n'existe pas contrairement à la méthode discard.


>>> set_notes.remove(20)
>>> print(set_notes)
{8, 12, 15, 17}

Vider le set avec la méthode clear.

Dans l'exemple suivant on enlève tous les éléments de set_notes.


>>> set_notes.clear()
>>> print(set_notes)
set()

Opérations booléennes

L'union, l'intersection, la différence.

Union de 2 ensembles

Avec la méthode union ou avec l'opérateur |


>>> set_notes2 = {6, 13, 17}
>>> set_notes.union(set_notes2)
>>> set_notes | set_notes2
{17, 6, 8, 12, 13, 15}

Intersection de 2 ensembles

Avec la méthode intersection ou avec l'opérateur &


>>> set_notes.intersection(set_notes2)
>>> set_notes & set_notes2
{17}

Différence de 2 ensembles

Avec la méthode difference ou avec l'opérateur -


>>> set_notes.difference(set_notes2)
>>> set_notes - set_notes2
{8, 12, 15}

Les dictionnaires

Un dictionnaire est un ensemble de paires clé-valeur. Il est mutable, ordonné avec des clés uniques.

Création

Les accolades permettent aussi de créer un dictionnaire.
Il s'écrit mon_dictionnaire = {cle1: valeur1, cle2: valeur2}

			
>>> ma_voiture = {'couleur': 'rouge', 'annee': 2020)

Initialisation et conversion

La fonction dict() permet de créer un dictionnaire vide.

			
>>> mon_dict = dict()
>>> print(type(mon_dict))

Elle permet aussi de transformer 2 listes en dictionnaire avec la fonction zip.

				
>>> couleurs = ['couleur', 'annee']
>>> proprietes = ['rouge', 2020]
>>> ma_voiture = dict(zip(couleurs, proprietes))
>>> print(ma_voiture)
{'couleur': 'rouge', 'annee': 2020}

Accéder à une valeur avec sa clé

Dans l'exemple suivant, on cherche la valeur correspondant à la clé couleur.

				
>>> print(ma_voiture['couleur'])
rouge

Cela permet aussi de modifier un couple clé-valeur ou de l'ajouter s'il n'existe pas.

				
>>> ma_voiture['puissance'] = 90
>>> print(ma_voiture)
{'couleur': 'rouge', 'annee': 2020, 'puissance': 90}

Boucler sur les clés et les valeurs d'un dictionnaire

La méthode keys permet de boucler sur les clés d'un dictionnaire.

				
>>> for key in ma_voiture.keys():
...     print(key)
couleur
annee
puissance
marque

La méthode values permet de boucler sur les valeurs d'un dictionnaire.

				
>>> for value in ma_voiture.values():
...     print(value)
rouge
2020
90
Renault

La méthode items permet de boucler sur les paires clé-valeur d'un dictionnaire.

				
>>> for key, value in ma_voiture.items():
...     print(f"{key}: {value}")
couleur: rouge
annee: 2020
puissance: 90
marque: Renault

Fusionner 2 dictionnaires

La méthode update permet d'ajouter le contenu d'un dictionnaire à un autre.

				
>>> marque_ma_voiture = {'marque': 'Renault'}
>>> ma_voiture.update(marque_ma_voiture)
>>> print(ma_voiture)
{'couleur': 'rouge', 'annee': 2020, 'puissance': 90, 'marque': 'Renault'}

Les boucles

La boucle for et la boucle while

La boucle for

La boucle for pour un nombre d’itérations connu.


>>> for i in range(4):
...     print(i)
0
1
2
3

La boucle while

La boucle while tant qu'une condition est vérifiée.

								
>>> x = 0
>>> my_list = []
>>> while x < 4:
...     my_list.append(x)
...     x += 1
...     print(my_list)
[0, 1, 2, 3]

Les conditions

Les opérateurs de comparaison, la structure conditionnelle et les opérateurs logiques

Les opérateurs de comparaison

Ils permettent d'effectuer les tests conditionnels.

Le tableau suivant présentes les opérateurs de comparaison.

Opérateur	Description	Exemple	Résultat
==	Égal à	2 == 2	True
!=	Différent de	2 != 3	True
<	Inférieur à	3 < 2	False
<=	Inférieur égale à	2 <= 3	True
>	Supérieur à	3 < 2	False
>=	Supérieur égale à	3 >= 2	True
is	Identique à	True is False	False
is not	Non identique à	True is not False	True

Dans l'exemple suivant, on teste si le pris est supérieur à 10.


>>> prix = int(input("prix: "))
prix: 32
>>> if prix > 10:
...     print("Pas d'erreur de prix")
Pas d'erreur de prix

La structure conditionnelle

Elle s'écrit if elif else.


>>> if prix > 50:
...     print("C'est trop cher")
... elif prix > 10:
...     print("C'est bon marché")
... else:
...     print("Erreur de prix")
C'est bon marché

Les opérateurs logiques

Les opérateurs and, or, not

Le tableau suivant présente les opérateurs logiques.

Opérateur	Description	Exemple	Résultat
and	ET	True and False	False
or	OU	True or False	True
not	NON	not True	False

Dans l'exemple suivant, on teste si le prix est compris entre 10 et 100 avec l'opérateur logique and.


>>> if prix < 50 and prix > 10:
...     print("C'est bon marché")
C'est bon marché

Les fonctions

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.

Création

Une fonction s'écrit def ma_fonction(paramètres):
Le mot-clé return permet de renvoyer le résultat, mais ce n'est pas obligatoire.

								
>>> def carre(x):
...     resultat = x * x
...     return resultat

Appel

Pour appeler une fonction on écrit ma_fonction(paramètres)
Il est alors possible de récupérer le resultat comme dans l'exemple suivant.

								
>>> resultat = carre(3)
>>> print(resultat)
9

Les fonctions lambda

Une fonction lambda est une fonction avec une syntaxe concise qui s'écrit sur une seule ligne.
Reprenons l'exemple précédent avec une fonction lambda.

								
>>> carre = lambda x : x * x
>>> resultat = carre(3)
>>> print(resultat)
9

Bibliothèques

La bibliothèque standard, les bibliothèques externes, l'environnement virtuel

La bibliothèque standard

La bibliothèque standard comprend de nombreux modules inclus dans l'installation de Python.

Le tableau suivant présente quelques modules de la bibliothèque standard.

Module	Description
os	Interactions avec le système d'exploitation
sys	Accès à des variables et fonctions du système
pathlib	Manipulation orientée objet des chemins de fichiers
random	Génération de nombres aléatoires
math	Fonctions mathématiques
subprocess	Création et gestion de processus externes
re	Expressions régulières
datetime	Manipulation des dates et heures
csv	Lecture et écriture de fichiers CSV
turtle	Animation graphique

Le module math

Dans l'exemple suivant, on importe le module math pour utiliser la constante pi.


>>> import math
>>> pi_value = math.pi
>>> print(pi_value)
3.141592653589793

Les bibliothèques externes

Ce sont des modules python développés par des tiers. Ils fournissant des outils, des frameworks ou des fonctionnalités supplémentaires. Ils sont la richesse du langage python.
Voir le site pypi avec l'ensemble des packages officiels

Le tableau suivant présente quelques bibliothèque externes dans différents domaines.

Package	Domaine
Pandas	Science des Données
Matplotlib	Graphiques
Scikit-learn	Machine Learning
Django	Framework web
Pillow	Traitement d'Images
PyQt	Interface graphique
Pygame	Jeux 2D

Installation

La commande pip install permet d'installer une bibliothèque externe, par exemple le package Pandas.

```
> pip install pandas
```

Environnement virtuel

Le module venv

Il permet de créer un environnement virtuel python dans un dossier.
L'intéret est d'installer les bibliothèques spécifiques utiles au projet dans cet environnement virtuel.

Création

Avec la commande venv

```
			
> python -m venv env
```

Activation

Sous powershell Windows
Le Set-ExecutionPolicy est à faire seulement une fois.


> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser	
> .\env\Scripts\Activate.ps1

Sous Linux

```
> source env/bin/activate
```

Désactivation

Avec la commande deactivate

```
> deactivate
```