Python: Apprendre Python

Un guide complet sur Python

👋 Bienvenue sur la documentation de Stackhero !

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

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

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

Ce guide offre un aperçu des concepts et de la syntaxe essentiels de Python. Il sert de rappel rapide pour les développeurs expérimentés et d'introduction conviviale pour les débutants. Couvrant tout, des types de données de base aux fonctionnalités avancées, cette feuille de triche inclut des sujets tels que le contrôle de flux, les fonctions, les classes, les objets et les modules courants. Gardez-le à 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, donc explorer des ressources et documentations supplémentaires vous aidera à 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 populaire pour sa lisibilité et sa simplicité, ce qui en fait un excellent choix pour les débutants comme 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.

Quelques cas d'utilisation courants de Python incluent 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, et le développement de modèles de machine learning avec des outils comme TensorFlow et scikit-learn.

La vaste bibliothèque standard de Python et son écosystème florissant de packages tiers en font un langage puissant et flexible pour aborder une large gamme 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 avec décimales), les booléens (valeurs vrai/faux) et les chaînes de caractères (séquences de caractères) :

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

Exemple :

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

Structures de données courantes

Python fournit plusieurs structures de données pour vous aider à organiser, stocker et manipuler efficacement les données. Les plus couramment utilisées sont les listes, les tuples, les dictionnaires et les ensembles. Les listes et les tuples maintiennent une séquence ordonnée d'éléments, les dictionnaires stockent des paires clé-valeur, et les ensembles stockent des éléments uniques. Chaque structure propose une gamme de méthodes adaptées à des cas d'utilisation 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 d'éléments mutables et ordonnées. Elles permettent les doublons et peuvent contenir des éléments de divers types de données, y compris d'autres listes, tuples, dictionnaires ou ensembles. Vous pouvez facilement ajouter, mettre à jour et supprimer des éléments. Les listes sont définies entre crochets [] avec des éléments séparés par des virgules.

Points clés sur les listes :

1. Mutables et ordonnées
2. Permettent les éléments dupliqués
3. Maintiennent l'ordre d'ajout des éléments
4. Supportent plusieurs types de données
5. Fournissent des opérations pour ajouter, mettre à jour et supprimer des éléments

Les listes sont couramment 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])  # Sortie : 1
print(my_list[-1])  # Sortie : 5

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

# Mettre à jour des éléments
my_list[0] = 0
print(my_list)  # Sortie : [0, 2, 3, 4, 5, 6]

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

Dictionnaires

Les dictionnaires sont des collections mutables et non ordonnées de paires clé-valeur. Chaque clé doit être unique, et vous pouvez utiliser ces clés pour accéder à leurs valeurs associées. Comme les listes, les dictionnaires peuvent stocker des éléments de divers types de données, y compris des collections imbriquées. Ils sont définis entre accolades {} avec des paires clé-valeur séparées par des virgules, et des clés et valeurs séparées par un deux-points.

Points clés sur les dictionnaires :

1. Collection mutable et non ordonnée
2. Composée de paires clé-valeur avec des clés uniques
3. Accès aux valeurs à l'aide des clés
4. Stockent divers types de données

Les dictionnaires sont idéaux pour les tâches nécessitant des recherches, telles que 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'])  # Sortie : 1

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

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

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

Tuples

Les tuples sont des collections immuables et ordonnées d'éléments. Ils fonctionnent comme les listes, sauf qu'une fois un tuple créé, ses éléments ne peuvent pas être modifiés, ajoutés ou supprimés. Les tuples sont définis à l'aide de parenthèses () avec des éléments 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 inchangeable, ou lorsque 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])  # Sortie : 1
print(my_tuple[-1])  # Sortie : 5

# Remarque : Les tuples sont immuables

Ensembles

Les ensembles sont des collections mutables et non ordonnées qui stockent des éléments uniques. Ils suppriment automatiquement les doublons et ne maintiennent pas d'ordre. Les ensembles peuvent contenir des éléments de divers types de données, à l'exclusion des types mutables comme les listes et les dictionnaires. Ils peuvent être définis à l'aide d'accolades {} ou du constructeur set().

Points clés sur les ensembles :

1. Mutables et non ordonnés
2. Stockent uniquement des éléments uniques, supprimant automatiquement les doublons
3. Excluent les types mutables (comme les listes et les dictionnaires)

Les ensembles sont idéaux pour les tests d'appartenance, la déduplication et les opérations d'ensemble comme l'union, l'intersection et la différence.

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

# Vérifier l'appartenance
print(1 in my_set)  # Sortie : True

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

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

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

Instructions conditionnelles : if, elif, else

Les instructions conditionnelles vous permettent d'exécuter du code en fonction de la véracité d'une condition.

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

Exemple :

x = 42

if x > 50:
  print("x est supérieur à 50")
elif x < 50:
  print("x est inférieur à 50")
else:
  print("x est égal à 50")

Boucle for

Les boucles for itèrent sur une séquence, telle qu'une liste ou une plage, en exécutant 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 encapsulent du code en blocs réutilisables qui peuvent accepter des entrées (arguments) et retourner des sorties. Elles sont définies à l'aide du 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)  # Sortie : 7

Fonctions lambda

Les fonctions lambda, également appelées fonctions anonymes, sont des fonctions concises à une seule expression créées à l'aide du mot-clé lambda. Elles sont couramment utilisées pour des opérations courtes, souvent comme arguments pour des fonctions comme map(), filter(), ou sorted().

lambda arguments: expression

Exemple :

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

Compréhensions de liste

Les compréhensions de liste vous permettent de créer des listes en une seule ligne lisible en combinant une expression avec une boucle et une condition optionnelle. Elles sont excellentes 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)  # Sortie : [1, 4, 9, 16, 25]

Gestion des exceptions

La gestion des exceptions permet à votre programme de gérer les erreurs d'exécution de manière élégante. Python fournit les blocs try, except, et finally pour intercepter et gérer les exceptions, garantissant que votre programme continue ou se termine en douceur.

try:
    # code qui peut lever une exception
except ExceptionType as error_variable:
    # gérer l'exception
finally:
    # code à exécuter qu'une exception se soit produite ou non

Exemple :

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Impossible de diviser par zéro !")

Classes et objets

Les classes définissent des plans pour créer des objets en programmation orientée objet (OOP). Les objets sont des instances d'une classe avec des attributs (données) et des méthodes (fonctions) qui effectuent 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()  # Sortie : Woof!

Importation de modules

Les modules sont des fichiers séparés contenant du code Python tel que des fonctions, des classes ou des variables. L'importation de modules vous 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))  # Sortie : 4.0

Entrée/Sortie de fichiers

L'entrée/sortie (I/O) de fichiers couvre la lecture et l'écriture de fichiers en Python. Ceci est essentiel lors du travail avec le stockage et la récupération de 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('contenu à écrire dans le fichier')

Gestionnaires de contexte

Les gestionnaires de contexte aident à gérer les ressources, telles que les fichiers ou les connexions réseau, en s'assurant qu'elles sont correctement acquises et libérées. L'utilisation d'un gestionnaire de contexte garantit que votre code est plus propre et plus tolérant aux erreurs.

with resource as alias:
  # utiliser resource comme alias

Exemple :

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

Décorateurs

Les décorateurs vous permettent d'étendre ou de modifier le comportement des fonctions ou des 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 enveloppé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 avoir appelé la fonction
    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"))  # Sortie : Hello, John!

Module Itertools

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

Exemple :

import itertools

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

Module Collections

Le module collections offre 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)  # Sortie : Alice 30

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

# Counter
count = Counter("hello world")
print(count)  # Sortie : 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)  # Sortie : OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Sortie : 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 fournit des fonctions telles que 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)  # Sortie : ['10', '5']

Dates et heures

Travailler avec les dates et les heures est une exigence courante, en particulier pour l'analyse de données ou les tâches de planification. Le module datetime fournit des classes et des fonctions pour travailler avec les dates, les heures et les intervalles.

import datetime

# datetime, date, time, timedelta, timezone

Exemples :

from datetime import datetime, timedelta

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

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

# Convertir 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("Chaîne en datetime :", date_obj)

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

# Arithmétique des dates et heures
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Hier :", yesterday)
print("Demain :", tomorrow)

Découpage de liste

Le découpage de liste vous permet d'extraire une portion d'une liste ou d'un autre type de séquence en spécifiant des valeurs de début, de fin et de pas optionnel. 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)  # Sortie : [1, 2, 3]

Formatage de chaînes

Le formatage de chaînes est le processus de combinaison de texte statique avec des valeurs dynamiques. Python offre plusieurs méthodes de formatage, y compris le formatage avec %, la méthode str.format(), et les f-strings (Python 3.6+), qui vous permettent de générer facilement des chaînes formatées.

Formatage avec %

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)  # Sortie : My name is John and I am 30 years old.

Arguments en ligne de commande

Les arguments en ligne de commande vous permettent de passer des valeurs d'entrée à un script Python lors de son exécution depuis la ligne de commande. La liste sys.argv fournit l'accès à ces arguments, facilitant leur analyse et leur utilisation 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
# Sortie attendue : Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("Aucun argument fourni.")