Python: Apprendre Python

Un guide Python complet

👋 Bienvenue sur la documentation de Stackhero !

Stackhero propose une solution Python cloud prête à l'emploi qui offre de nombreux avantages, notamment :

• Déployez votre application en quelques secondes avec un simple git push.
• Utilisez votre propre nom de domaine et profitez de la configuration automatique des certificats HTTPS pour une sécurité renforcée.
• Bénéficiez de sauvegardes automatiques, de mises à jour en un clic, ainsi que d'une tarification simple, transparente et prévisible.
• Profitez d'une performance optimale et d'une sécurité renforcée grâce à une VM privée et dédiée.

Gagnez du temps et simplifiez-vous la vie : il suffit de 5 minutes pour essayer la solution d'hébergement Python cloud de Stackhero !

Ce guide propose un aperçu des concepts et de la syntaxe essentiels de Python. Il sert à la fois de rappel rapide pour les développeurs expérimentés et d'introduction accessible pour les débutants. Couvrant tout, des types de données de base aux fonctionnalités avancées, cette cheatsheet aborde des sujets comme le contrôle de flux, les fonctions, les classes, les objets et les modules courants. Gardez-la à portée de main comme référence rapide lors de vos projets Python. Gardez à l'esprit que Python dispose d'un vaste écosystème de bibliothèques et de frameworks, explorer d'autres ressources et la documentation vous permettra d'approfondir des sujets spécialisés.

Bon codage !

Introduction à Python

Python est un langage de programmation polyvalent et de haut niveau, créé par Guido van Rossum et publié pour la première fois en 1991. Il est apprécié pour sa lisibilité et sa simplicité, ce qui en fait un excellent choix aussi bien pour les débutants que pour les développeurs expérimentés. Python est largement utilisé dans le développement web, l'analyse de données, l'intelligence artificielle, le machine learning et l'automatisation, entre autres domaines.

Parmi les cas d'usage courants de Python, on retrouve la création d'applications web avec des frameworks comme Django ou Flask, l'analyse et la visualisation de données avec des bibliothèques telles que pandas et matplotlib, ou encore le développement de modèles de machine learning avec des outils comme TensorFlow et scikit-learn.

La bibliothèque standard très complète de Python et son écosystème dynamique de packages tiers en font un langage puissant et flexible pour aborder une grande variété de tâches de programmation.

Types de données de base

Les types de données de base de Python incluent les entiers (nombres entiers), les nombres à virgule flottante (nombres décimaux), les booléens (valeurs vrai/faux) et les chaînes de caractères (séquences de caractères) :

• int : Entier, par exemple 42
• float : Nombre à virgule flottante, par exemple 3.14
• bool : Booléen, par exemple True ou False
• str : Chaîne de caractères, par exemple "hello"

Exemple :

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Structures de données courantes

Python propose plusieurs structures de données pour organiser, stocker et manipuler efficacement vos données. Les plus utilisées sont les listes, tuples, dictionnaires et ensembles. Les listes et tuples conservent un ordre, les dictionnaires stockent des paires clé-valeur, et les ensembles contiennent uniquement des éléments uniques. Chaque structure dispose de méthodes adaptées à des besoins spécifiques.

• Liste : my_list = [1, 2, 3, 4]
• Tuple : my_tuple = (1, 2, 3, 4)
• Dictionnaire : my_dictionary = {'key1': 'value1', 'key2': 'value2'}
• Ensemble : my_set = {1, 2, 3, 4}

Listes

Les listes sont des collections ordonnées et modifiables d'éléments. Elles acceptent les doublons et peuvent contenir différents types de données, y compris d'autres listes, tuples, dictionnaires ou ensembles. Vous pouvez facilement ajouter, modifier ou supprimer des éléments. Les listes sont définies avec des crochets [] et les éléments sont séparés par des virgules.

Points clés sur les listes :

1. Modifiables et ordonnées
2. Acceptent les éléments dupliqués
3. Conservent l'ordre d'ajout des éléments
4. Supportent plusieurs types de données
5. Permettent d'ajouter, modifier et supprimer des éléments

Les listes sont très utilisées lorsque vous avez besoin d'une collection dynamique et redimensionnable d'éléments.

Exemples :

# Créer une liste
my_list = [1, 2, 3, 4, 5]

# Accéder aux éléments
print(my_list[0])  # Affiche : 1
print(my_list[-1])  # Affiche : 5

# Ajouter des éléments
my_list.append(6)
print(my_list)  # Affiche : [1, 2, 3, 4, 5, 6]

# Modifier des éléments
my_list[0] = 0
print(my_list)  # Affiche : [0, 2, 3, 4, 5, 6]

# Supprimer des éléments
del my_list[0]
print(my_list)  # Affiche : [2, 3, 4, 5, 6]

Dictionnaires

Les dictionnaires sont des collections modifiables et non ordonnées de paires clé-valeur. Chaque clé doit être unique et permet d'accéder à sa valeur associée. Comme les listes, les dictionnaires peuvent contenir différents types de données, y compris des collections imbriquées. Ils sont définis avec des accolades {} et les paires clé-valeur sont séparées par des virgules, la clé et la valeur étant séparées par un deux-points.

Points clés sur les dictionnaires :

1. Collection modifiable et non ordonnée
2. Composée de paires clé-valeur avec des clés uniques
3. Accès aux valeurs via les clés
4. Stockent différents types de données

Les dictionnaires sont idéaux pour les recherches rapides, comme les paramètres de configuration ou les comptages de fréquence.

Exemples :

# Créer un dictionnaire
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Accéder aux éléments
print(my_dictionary['a'])  # Affiche : 1

# Ajouter des éléments
my_dictionary['d'] = 4
print(my_dictionary)  # Affiche : {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Modifier des éléments
my_dictionary['a'] = 0
print(my_dictionary)  # Affiche : {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Supprimer des éléments
del my_dictionary['a']
print(my_dictionary)  # Affiche : {'b': 2, 'c': 3, 'd': 4}

Tuples

Les tuples sont des collections ordonnées et immuables d'éléments. Ils fonctionnent comme les listes, à la différence qu'une fois créés, leurs éléments ne peuvent plus être modifiés, ajoutés ou supprimés. Les tuples sont définis avec des parenthèses () et les éléments sont séparés par des virgules.

Points clés sur les tuples :

1. Collection immuable et ordonnée
2. Supportent plusieurs types de données
3. Structure de taille fixe

Les tuples sont utiles lorsque vous avez besoin d'une collection non modifiable, ou si vous souhaitez utiliser la collection comme clé de dictionnaire.

Exemple :

# Créer un tuple
my_tuple = (1, 2, 3, 4, 5)

# Accéder aux éléments
print(my_tuple[0])  # Affiche : 1
print(my_tuple[-1])  # Affiche : 5

# Remarque : Les tuples sont immuables

Ensembles

Les ensembles sont des collections modifiables et non ordonnées qui ne contiennent que des éléments uniques. Ils éliminent automatiquement les doublons et ne conservent pas l'ordre. Les ensembles peuvent contenir différents types de données, à l'exception des types modifiables comme les listes et les dictionnaires. Ils peuvent être définis avec des accolades {} ou le constructeur set().

Points clés sur les ensembles :

1. Modifiables et non ordonnés
2. Ne stockent que des éléments uniques, suppression automatique des doublons
3. Excluent les types modifiables (comme les listes et dictionnaires)

Les ensembles sont parfaits pour tester l'appartenance, dédupliquer des données ou effectuer des opérations ensemblistes comme l'union, l'intersection ou la différence.

# Créer un ensemble
my_set = {1, 2, 3, 4, 5}

# Tester l'appartenance
print(1 in my_set)  # Affiche : True

# Ajouter un élément
my_set.add(6)
print(my_set)  # Affiche : {1, 2, 3, 4, 5, 6}

# Mettre à jour en supprimant un élément et en en ajoutant un autre
my_set.remove(1)
my_set.add(0)
print(my_set)  # Affiche : {0, 2, 3, 4, 5, 6}

# Supprimer un élément
my_set.remove(0)
print(my_set)  # Affiche : {2, 3, 4, 5, 6}

Instructions conditionnelles : if, elif, else

Les instructions conditionnelles permettent d'exécuter du code selon qu'une condition est vraie ou fausse.

if condition1:
  # faire quelque chose
elif condition2:
  # faire autre chose
else:
  # faire une autre chose

Exemple :

x = 42

if x > 50:
  print("x is greater than 50")
elif x < 50:
  print("x is less than 50")
else:
  print("x is equal to 50")

Boucle for

Les boucles for permettent d'itérer sur une séquence, comme une liste ou une plage, et d'exécuter un bloc de code pour chaque élément.

Exemple :

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

Boucle while

Les boucles while exécutent un bloc de code tant qu'une condition spécifiée est vraie.

Exemple :

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

Fonctions

Les fonctions permettent d'encapsuler du code dans des blocs réutilisables qui peuvent accepter des entrées (arguments) et retourner des résultats. Elles sont définies avec le mot-clé def et peuvent être appelées par leur nom.

def function_name(argument1, argument2=default_value):
  # faire quelque chose
  return result

Exemple :

def add(a, b):
  return a + b

result = add(3, 4)
print(result)  # Affiche : 7

Fonctions lambda

Les fonctions lambda, ou fonctions anonymes, sont des fonctions courtes à une seule expression créées avec le mot-clé lambda. Elles sont souvent utilisées pour des opérations simples, notamment comme arguments pour map(), filter() ou sorted().

lambda arguments: expression

Exemple :

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Affiche : 7

Compréhensions de liste

Les compréhensions de liste permettent de créer des listes en une seule ligne lisible, en combinant une expression, une boucle et une condition optionnelle. Elles sont idéales pour transformer ou filtrer des données.

new_list = [expression for item in iterable if condition]

Exemple :

squares = [x * x for x in range(1, 6)]
print(squares)  # Affiche : [1, 4, 9, 16, 25]

Gestion des exceptions

La gestion des exceptions permet à votre programme de traiter les erreurs d'exécution de manière élégante. Python propose les blocs try, except et finally pour intercepter et gérer les exceptions, garantissant ainsi la continuité ou l'arrêt propre du programme.

try:
    # code susceptible de lever une exception
except ExceptionType as error_variable:
    # gérer l'exception
finally:
    # code exécuté dans tous les cas

Exemple :

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Cannot divide by zero!")

Classes et objets

Les classes définissent des modèles pour créer des objets en programmation orientée objet (OOP). Les objets sont des instances de classe avec des attributs (données) et des méthodes (fonctions) qui réalisent des tâches spécifiques. L'OOP favorise un code structuré, réutilisable et maintenable.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # faire quelque chose
    return result

Exemple :

class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def bark(self):
    print("Woof!")

# Créer une instance de Dog
dog1 = Dog("Buddy", 3)
dog1.bark()  # Affiche : Woof!

Importation de modules

Les modules sont des fichiers séparés contenant du code Python comme des fonctions, classes ou variables. Importer des modules permet d'étendre les fonctionnalités de votre programme en utilisant des bibliothèques et frameworks externes.

import module_name
from module_name import specific_function_or_class

Exemple :

import math
print(math.sqrt(16))  # Affiche : 4.0

Entrées/sorties de fichiers (File I/O)

Les opérations d'entrée/sortie sur fichiers (I/O) couvrent la lecture et l'écriture de fichiers en Python. C'est essentiel pour stocker et récupérer des données.

Lecture d'un fichier

with open('filename.txt', 'r') as file:
  content = file.read()

Écriture dans un fichier

with open('filename.txt', 'w') as file:
  file.write('content to write to the file')

Gestionnaires de contexte

Les gestionnaires de contexte facilitent la gestion des ressources, comme les fichiers ou les connexions réseau, en s'assurant qu'elles sont correctement acquises et libérées. Utiliser un gestionnaire de contexte rend votre code plus propre et plus robuste.

with resource as alias:
  # utiliser resource via alias

Exemple :

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Affiche : Hello, World!

Décorateurs

Les décorateurs permettent d'étendre ou de modifier le comportement de fonctions ou de classes sans changer leur code source. Ils enveloppent une autre fonction et ajoutent des fonctionnalités avant ou après l'exécution de la fonction décorée.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # faire quelque chose avant d'appeler la fonction
    result = func(*args, **kwargs)
    # faire quelque chose après l'appel
    return result
  return wrapper

@decorator_function
def my_function():
  # faire quelque chose

Exemples :

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Affiche : Hello, John!

Module itertools

Le module itertools fournit des fonctions pour créer et manipuler des itérateurs. Il inclut des itérateurs infinis (comme count, cycle, repeat), des itérateurs finis (comme accumulate, chain, compress) et des itérateurs combinatoires (comme product, permutations, combinations).

Exemple :

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Affiche : 5, 10, 15, 20

Module collections

Le module collections propose des types de conteneurs spécialisés qui peuvent améliorer vos programmes.

from collections import namedtuple, defaultdict, Counter, deque

Exemples :

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Affiche : Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Affiche : deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Affiche : Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Affiche : OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Affiche : defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Expressions régulières

Les expressions régulières permettent un traitement et une manipulation puissants du texte. Le module re propose des fonctions comme match, search, findall, finditer, split et sub.

Exemple :

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Affiche : ['10', '5']

Dates et heures

Travailler avec les dates et heures est fréquent, notamment pour l'analyse de données ou la planification de tâches. Le module datetime fournit des classes et fonctions pour manipuler les dates, heures et intervalles.

import datetime

# datetime, date, time, timedelta, timezone

Exemples :

from datetime import datetime, timedelta

# Date et heure actuelles
current_time = datetime.now()
print("Current date and time:", current_time)

# Date et heure personnalisées
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Custom date and time:", custom_date)

# Conversion d'une chaîne en datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("String to datetime:", date_obj)

# Conversion d'un datetime en chaîne
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime to string:", date_str2)

# Calculs sur les dates et heures
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Yesterday:", yesterday)
print("Tomorrow:", tomorrow)

Découpage de listes (slicing)

Le découpage de listes permet d'extraire une portion d'une liste ou d'une autre séquence en précisant des indices de début, de fin et éventuellement un pas. Cette fonctionnalité est très utile pour extraire des sous-séquences.

my_list[start:end:step]

Exemple :

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Affiche : [1, 2, 3]

Formatage de chaînes de caractères

Le formatage de chaînes consiste à combiner du texte statique avec des valeurs dynamiques. Python propose plusieurs méthodes de formatage, dont le %-formatting, la méthode str.format() et les f-strings (Python 3.6+), qui permettent de générer facilement des chaînes formatées.

%-formatting

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Exemple :

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Affiche : My name is John and I am 30 years old.

Arguments en ligne de commande

Les arguments en ligne de commande permettent de transmettre des valeurs à un script Python lors de son exécution depuis le terminal. La liste sys.argv donne accès à ces arguments, ce qui facilite leur traitement dans votre script.

import sys

arguments = sys.argv

Exemple :

# Enregistrez ce code dans un fichier nommé "cmd_args.py"
# Exécutez avec : python cmd_args.py Alice
# Résultat attendu : Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("No arguments provided.")