Python cheat sheet

Introduction Rapide à Python

Python est un langage de programmation de haut niveau, interprété et de script, conçu avec l’objectif d’être lisible et simple à utiliser. Il a été créé par Guido van Rossum et publié pour la première fois en 1991. Python est devenu extrêmement populaire pour le développement logiciel, le calcul scientifique, l’analyse de données, l’intelligence artificielle, et bien plus encore.

Caractéristiques Principales

• Facile à apprendre et à utiliser : Python a une syntaxe très claire et lisible, ce qui le rend accessible aux débutants en programmation.
• Interprété : Python est exécuté ligne par ligne, ce qui facilite le test rapide de nouveaux concepts ou le débogage.
• Dynamiquement typé : Les types de variables sont déterminés au moment de l’exécution, ce qui rend le langage flexible et réduit le besoin de déclarations de types explicites.
• Vaste bibliothèque standard : Python vient avec une large bibliothèque standard, fournissant des outils adaptés à diverses tâches, de la manipulation de fichiers au calcul scientifique.
• Supporte la programmation orientée objet et fonctionnelle : Python permet des styles de programmation variés, y compris procédural, orienté objet, et fonctionnel.

Hello World en Python

                print("Hello, World!")
                

Ce programme affiche le message “Hello, World!” sur la console. C’est souvent le premier programme écrit par les personnes apprenant Python.

Syntaxe de Base de Python

Commentaires

• Ligne : # Mon commentaire
• Multilignes : ''' Mon commentaire ''' ou """ Mon commentaire """

Variables

• Déclaration : nom = 'Python' // Dynamiquement typé
• Constantes : NOM = 'Python' // Convention pour indiquer une constante

Types

• Entiers : age = 30
• Flottants : prix = 10.99
• Chaînes : nom = 'Python'
• Booléens : est_vrai = True
• Listes : numeros = [1, 2, 3]
• Tuples : dimensions = (100, 200)
• Dictionnaires : dictionnaire = {'cle': 'valeur'}
• Ensembles : noms = {'Python', 'Django'}

Opérateurs

• Arithmétiques : +, -, *, /, // (division entière), % (modulo), ** (puissance)
• Comparaison : ==, !=, >, <, >=, <=
• Logiques : and, or, not
• Membres : in, not in
• Identité : is, is not

Conversion de Types

• Vers entiers : int('123')
• Vers flottants : float('10.5')
• Vers chaînes : str(10)

Ceci offre un aperçu des éléments syntaxiques fondamentaux de Python, facilitant l’écriture et la compréhension des programmes Python.

Structures de Contrôle dans Python

Conditions

• if, elif, else:

  
                  if condition:
                      # code si condition est vraie
                  elif autre_condition:
                      # code si autre_condition est vraie
                  else:
                      # code si aucune des conditions précédentes n'est vraie
                  

Boucles

• for pour itérer sur des séquences (listes, tuples, dictionnaires, ensembles, chaînes) :

  
                  for element in sequence:
                      # action avec element
                  

• while pour répéter une action tant qu’une condition est vraie :

  
                  while condition:
                      # action tant que condition est vraie
                  

Contrôle de Boucle

• break pour sortir immédiatement de la boucle
• continue pour passer immédiatement à l’itération suivante
• else après une boucle for ou while, exécuté si la boucle n’a pas été interrompue par break

Compréhensions de Liste

Les compréhensions de liste fournissent une manière concise de créer des listes :

                [expression for item in iterable if condition]
                

• expression : C’est ce que chaque élément de la nouvelle liste sera. Cette expression peut inclure l’élément lui-même (par exemple, item) ou une transformation de celui-ci (par exemple, item * 2).
• item : La variable qui représente chaque élément de la liste source (ou de tout autre itérable) à chaque itération de la boucle.
• iterable : L’objet sur lequel vous itérez, comme une liste, un tuple, ou tout autre objet qui supporte l’itération.
• if condition : Une clause optionnelle pour filtrer les éléments de l’itérable. Seuls les éléments pour lesquels la condition est vraie seront inclus dans la nouvelle liste.

Exemple sans condition :

                # Crée une liste des carrés des nombres de 0 à 9
                carrés = [x ** 2 for x in range(10)]
                

Exemple avec condition :

                # Crée une liste des carrés des nombres pairs de 0 à 9
                carrés_pairs = [x ** 2 for x in range(10) if x % 2 == 0]
                

Dans le premier exemple, x ** 2 est l’expression, x est l’élément, et range(10) est l’itérable. Dans le second exemple, l’ajout de if x % 2 == 0 filtre l’itérable pour inclure seulement les nombres pairs avant d’appliquer l’expression x ** 2.

Fonctions et Méthodes dans Python

Déclaration de Fonctions

• Syntaxe de base :

  
                  def nom_fonction(parametres):
                      # Corps de la fonction
                  

• Exemple :

  
                  def dire_bonjour():
                      print("Bonjour")
                  

Paramètres et Retour

• Avec paramètres :

  
                  def saluer(nom):
                      print(f"Bonjour, {nom}")
                  

• Avec valeur de retour :

  
                  def creer_salutation(nom):
                      return f"Bonjour, {nom}"
                  

Paramètres Optionnels et Mots-clés

• Paramètres par défaut :

  
                  def configurer(couleur='blanc', actif=False):
                      print(f"Couleur : {couleur}, Actif : {actif}")
                  

• Paramètres nommés :

  
                  configurer(actif=True, couleur='bleu')
                  

Fonctions Lambda

• Fonctions anonymes stockées dans une variable :

  
                  somme = lambda a, b: a + b
                  print(somme(5, 3))
                  

Méthodes

• Fonctions définies à l’intérieur d’une classe :

  
                  class Voiture:
                      def klaxonner(self):
                          print("Tut tut!")
                  

Portée et Fermetures

• Les variables définies dans une fonction sont locales à celle-ci. Python permet la création de fermetures pour capturer et conserver les variables locales même après que la fonction externe ait été exécutée :

  
                  def externe(x):
                      def interne(y):
                          return x + y
                      return interne
                  

Les fonctions et méthodes en Python permettent de structurer le code en blocs réutilisables et maintenables, facilitant ainsi le développement de logiciels complexes.

Collections dans Python

Listes

• Déclaration : liste = [1, 2, 3]
• Accès à un élément : liste[0] // Accède au premier élément
• Modification : liste[0] = 10 // Modifie le premier élément
• Ajout : liste.append(4) // Ajoute un élément à la fin
• Suppression : liste.remove(2) // Supprime le premier élément avec la valeur 2

Tuples

• Déclaration : tuple = (1, 2, 3)
• Accès à un élément : tuple[0] // Les tuples sont immuables, donc pas de modification possible

Dictionnaires

• Déclaration : dictionnaire = {'cle1': 'valeur1', 'cle2': 'valeur2'}
• Accès à une valeur : dictionnaire['cle1']
• Modification/Ajout : dictionnaire['cle1'] = 'nouvelle valeur' // Modifie si la clé existe, sinon ajoute la clé avec la valeur
• Suppression : del dictionnaire['cle1'] // Supprime la clé et sa valeur

Ensembles

• Déclaration : ensemble = {1, 2, 3}
• Ajout : ensemble.add(4) // Ajoute un élément s’il n’est pas déjà présent
• Suppression : ensemble.remove(2) // Supprime un élément s’il est présent

Opérations Courantes sur les Collections

• Longueur : len(collection) // Fonctionne pour listes, tuples, dictionnaires, et ensembles
• Itération : for element in collection: // Parcours de chaque élément
• Compréhensions : [x for x in collection if condition] // Crée une nouvelle liste basée sur des conditions

Les collections en Python sont des structures de données puissantes qui permettent de stocker, manipuler, et accéder efficacement à des ensembles de données.

Programmation Asynchrone dans Python

La programmation asynchrone en Python est principalement gérée par le module asyncio, qui fournit l’infrastructure pour écrire des programmes asynchrones à l’aide de async et await.

Async et Await

• async déclare une fonction asynchrone. await est utilisé pour attendre qu’une opération asynchrone se termine.

  
                  async def charger_donnees():
                      return 'Données chargées'
                  
                  async def afficher_donnees():
                      donnees = await charger_donnees()
                      print(donnees)
                  

Gestion des Erreurs

• La gestion des erreurs dans les fonctions asynchrones se fait via try, except, et finally.

  
                  async def traiter_donnees():
                      try:
                          donnees = await charger_donnees()
                          print(donnees)
                      except Exception as e:
                          print(f'Erreur: {e}')
                      finally:
                          print('Nettoyage')
                  

Streams

• Les Streams permettent de traiter des séquences de données asynchrones.

  
                  import asyncio
                  
                  async def compter():
                      for i in range(1, 4):
                          await asyncio.sleep(1)
                          yield i
                  
                  async def ecouter_comptage():
                      async for compteur in compter():
                          print(compteur)
                  

Utilisation de Futures et Streams

• Future et Stream sont utilisés pour des opérations I/O, comme les requêtes réseau ou les lectures/écritures de fichiers, permettant à l’application de rester réactive.

La programmation asynchrone est essentielle pour développer des applications Python efficaces, en particulier pour les I/O bound et les applications réseau.

Tests dans Python

Introduction aux Tests

• Les tests sont cruciaux pour vérifier la fiabilité et la qualité de votre code.
• Python utilise principalement deux frameworks de test : unittest et pytest.

Unittest

• Inclus dans la bibliothèque standard de Python, il est inspiré par JUnit.

  
                  import unittest
                  
                  class TestSimple(unittest.TestCase):
                      def test_addition(self):
                          self.assertEqual(1 + 1, 2)
                  
                  if __name__ == '__main__':
                      unittest.main()
                  

Pytest

• Framework de test tiers offrant une syntaxe plus simple et des fonctionnalités avancées.

  
                  def test_addition():
                      assert 1 + 1 == 2
                  

  Exécutez les tests en utilisant la commande : pytest fichier_test.py

Assertions

• Vérifiez que les conditions sont vraies avec assert.

  
                  assert condition, "Message si la condition n'est pas satisfaite"
                  

Mocking

• Simuler des dépendances pour isoler les tests.

  
                  from unittest.mock import MagicMock
                  dependance = MagicMock()
                  

Organisation des Tests

• Regroupez les tests relatifs dans des fichiers séparés et utilisez des dossiers pour structurer les tests par fonctionnalité ou module.

La mise en œuvre de tests unitaires et d’intégration robustes est essentielle pour maintenir la qualité du code et faciliter les mises à jour ou les refactorisations sans introduire de régressions.

Environnements Virtuels et Gestion des Paquets

venv

• venv permet de créer des environnements virtuels pour isoler les dépendances des projets.

  
                  python -m venv mon_env
                  

• Activer l’environnement virtuel :
  • Sur Windows : .\mon_env\Scripts\activate
  • Sur Unix ou MacOS : source mon_env/bin/activate

pip

• pip est le gestionnaire de paquets pour Python, utilisé pour installer et gérer les bibliothèques et dépendances.

  
                  pip install nom_du_paquet
                  

• Liste des paquets installés : pip list
• Mettre à jour un paquet : pip install --upgrade nom_du_paquet
• Générer un fichier de dépendances : pip freeze > requirements.txt
• Installer à partir d’un fichier de dépendances : pip install -r requirements.txt

Ces outils sont fondamentaux pour le développement Python, assurant que les projets soient reproductibles et que les environnements de développement restent propres et bien organisés.