Les expressions régulières (ou RegEx) sont une séquence de caractères qui forment un modèle de recherche, principalement utilisé pour la vérification de formes et l’extraction de parties spécifiques d’un texte. Python possède une bibliothèque intégrée appelée

qui permet de travailler avec des expressions régulières.

Voici quelques exemples d’utilisation des expressions régulières en Python:

import re

# Vérifier si une chaîne de caractères correspond à un modèle
if re.search("hello", "hello world"):
    print("Motif trouvé")

# Extraire des parties d'une chaîne de caractères
result = re.search("([a-z]+) ([a-z]+)", "hello world")
print(result.groups())  # affiche ("hello", "world")

# Remplacer des parties d'une chaîne de caractères
text = "hello world"
modified_text = re.sub("world", "universe", text)
print(modified_text)  # affiche "hello universe"

# Trouver toutes les occurences d'un motif dans un texte
for match in re.finditer("l", "hello world"):
    print(match.start())  # affiche 2, 3, 9

Il y a beaucoup plus de choses que vous pouvez faire avec les expressions régulières en Python, je vous suggère de lire la documentation officielle de la bibliothèque

pour en savoir plus

L’héritage en Python permet à une classe de dériver de caractéristiques et de comportements d’une classe parente, ce qui peut être très utile pour réutiliser du code et organiser votre programme de manière logique. Voici un exemple de définition de classes en Python qui utilise l’héritage:

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

    def make_sound(self):
        print("Some generic animal sound")

class Cat(Animal):
    def __init__(self, name, breed, toy):
        super().__init__(name, species="Cat")  # Appel de la méthode __init__ de la classe parente
        self.breed = breed
        self.toy = toy

    def make_sound(self):
        print("Meow")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, species="Dog")  # Appel de la méthode __init__ de la classe parente
        self.breed = breed

    def make_sound(self):
        print("

Dans cet exemple, la classe

est la classe parente et les classes

et

sont des classes enfants qui héritent de

. Les classes enfants peuvent avoir leurs propres méthodes et attributs, mais elles peuvent également utiliser les méthodes et attributs de la classe parente en utilisant la fonction

.

Les fonctions lambda sont des fonctions courtes et simples qui sont définies en une seule ligne. Elles sont utiles pour créer des fonctions simples rapidement, généralement lorsqu’elles sont utilisées dans des contextes où une fonction standard ne serait pas pratique. Voici comment définir une fonction lambda en Python:

lambda arguments: expression

add = lambda x, y: x + y

result = add(3, 4)
print(result)  # affiche 7

Les fonctions lambda sont souvent utilisées en combinaison avec les fonctions

,

et

de Python, qui permettent d’appliquer une fonction à chaque élément d’une liste ou d’un objet itérable.

numbers = [1, 2, 3, 4]
doubled = map(lambda x: x * 2, numbers)
print(list(doubled))  # affiche [2, 4, 6, 8]

Voici comment compter le nombre de chaque voyelle dans une chaîne de caractères en utilisant Python :

def count_vowels(string):
    vowels = 'aeiouAEIOU'
    count = {}.fromkeys(vowels, 0)

    for character in string:
        if character in count:
            count[character] += 1

    return count

Dans cet exemple,

est la chaîne de caractères à analyser et

est un dictionnaire qui enregistre le nombre d’occurrences de chaque voyelle. Nous avons utilisé la méthode

pour créer un dictionnaire qui contient toutes les voyelles en tant que clés et initialise leur valeur à zéro. Nous avons utilisé une boucle

pour parcourir chaque caractère de la chaîne et mettre à jour le compteur si le caractère est une voyelle.

Voici comment multiplier deux matrices en utilisant Python :

def multiply_matrices(A, B):
    rows_A = len(A)
    cols_A = len(A[0])
    rows_B = len(B)
    cols_B = len(B[0])

    if cols_A != rows_B:
      raise ValueError("Les matrices ne peuvent pas être multipliées")

    # initialiser la matrice résultat à zéro
    C = [[0 for row in range(cols_B)] for col in range(rows_A)]

    for i in range(rows_A):
        for j in range(cols_B):
            for k in range(cols_A):
                C[i][j] += A[i][k] * B[k][j]

    return C

Dans cet exemple,

et

sont les matrices à multiplier, et

est la matrice résultat. Nous avons vérifié que les matrices peuvent être multipliées en vérifiant que le nombre de colonnes de

est égal au nombre de lignes de

. Si ce n’est pas le cas, nous avons levé une exception

. Sinon, nous avons initialisé la matrice résultat à zéro et avons utilisé une boucle triple

pour calculer le produit de chaque élément de

et de

.

Voici un exemple complet qui montre comment utiliser cette fonction pour multiplier deux matrices

et

:

A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]

C = multiply_matrices(A, B)

print(C)  # affiche : [[19, 22], [43, 50]]

Voici comment vous pouvez écrire un programme Python pour transposer une matrice :

transposed_matrix = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

def transpose_matrix(matrix):
  # créez la matrice transposée
  transposed_matrix = []
  for i in range(len(matrix[0])):
    transposed_matrix.append([])
    for j in range(len(matrix)):
      transposed_matrix[i].append(matrix[j][i])
  return transposed_matrix

# exemple d'utilisation
matrix = [[1, 2], [3, 4], [5, 6]]
result = transpose_matrix(matrix)
print(result)

Vous pouvez également utiliser la méthode

de Python pour transposer une matrice. Voici comment cela peut être fait :

transposed_matrix = list(map(list, zip(*matrix)))

Voici un exemple de code Python qui permet d’ajouter deux matrices :

def add_matrices(matrix1, matrix2):
  # Vérifiez que les matrices ont la même taille
  if len(matrix1) != len(matrix2) or len(matrix1[0]) != len(matrix2[0]):
    raise ValueError("Les matrices doivent avoir la même taille")
 
  # Créez une matrice vide pour stocker le résultat
  result = []
 
  # Parcourez les lignes de la première matrice
  for i in range(len(matrix1)):
    # Créez une liste vide pour stocker la ligne résultat
    result.append([])
    # Parcourez les colonnes de la première matrice
    for j in range(len(matrix1[0])):
      # Ajoutez les éléments correspondants des deux matrices
      result[i].append(matrix1[i][j] + matrix2[i][j])
 
  # Retournez la matrice résultat
  return result

# Exemple d'utilisation
matrix1 = [[1, 2, 3], [4, 5, 6]]
matrix2 = [[7, 8, 9], [10, 11, 12]]
result = add_matrices(matrix1, matrix2)
print(result)

programme Python pour ajouter deux matrices de même taille :

Voici comment supprimer les éléments en double d’une liste en utilisant Python :

unique_list = list(set(my_list))

my_list = [1, 2, 3, 3, 4, 4, 5]
unique_list = list(set(my_list))
print(unique_list)  # [1, 2, 3, 4, 5]

unique_list = []
seen = set()

for element in my_list:
  if element not in seen:
    unique_list.append(element)
    seen.add(element)

print(unique_list)  # [1, 2, 3, 4, 5]

Dans cet exemple,

est la liste originale et

est une nouvelle liste qui ne contient que des éléments uniques. Nous avons utilisé la fonction

pour convertir la liste en un ensemble, qui ne permet pas les éléments en double. Nous avons converti l’ensemble en une liste à l’aide de la fonction

, puis nous avons assigné le résultat à la variable

.

Voici un exemple complet qui montre comment supprimer les éléments en double d’une liste nommée

:

Vous pouvez également utiliser une boucle

pour parcourir la liste et ajouter chaque élément à un nouvel ensemble, puis convertir l’ensemble en une liste. Voici comment cela peut être fait :

Dans cet exemple, nous avons créé un ensemble vide nommé

pour stocker les éléments déjà vus. Nous avons parcouru la liste

et ajouté chaque élément à la liste

si il n’était pas déjà présent dans l’ensemble

. Nous avons utilisé la méthode

de l’ensemble pour ajouter chaque élément à l’ensemble. Cette approche est plus lente que la première approche, mais elle permet de conserver l’ordre des éléments dans la liste originale.

Voici un exemple de programme Python qui met en majuscule le premier caractère d’une chaîne de caractères:

def capitalize_first_character(string):
    return string[0].upper() + string[1:]

print(capitalize_first_character('hello'))  # Hello
print(capitalize_first_character('world'))  # World

def capitalize_first_character(string):
    return string.capitalize()

print(capitalize_first_character('hello'))  # Hello
print(capitalize_first_character('world'))  # World

La fonction

prend une chaîne de caractères en entrée et renvoie une nouvelle chaîne où le premier caractère est en majuscule et les autres caractères sont inchangés.

Vous pouvez également utiliser la méthode

de la classe

pour accomplir cette tâche:

Cette méthode met en majuscule le premier caractère de la chaîne et met les autres caractères en minuscules. Si la chaîne ne contient qu’un seul caractère, la méthode le mettra en majuscule.

Voici un exemple de programme Python qui vérifie si deux chaînes de caractères sont des anagrammes (c’est-à-dire si elles ont la même signification, mais peuvent être formées avec différentes combinaisons de lettres):

def is_anagram(string1, string2):
    # Créer des compteurs de caractères pour chaque chaîne
    char_count1 = {}
    char_count2 = {}

    # Remplir les compteurs de caractères
    for c in string1:
        if c in char_count1:
            char_count1[c] += 1
        else:
            char_count1[c] = 1
    for c in string2:
        if c in char_count2:
            char_count2[c] += 1
        else:
            char_count2[c] = 1

    # Vérifier si les compteurs de caractères sont égaux
    return char_count1 == char_count2

# Exemples d'utilisation de la fonction
print(is_anagram('abcdef', 'fedcba'))  # True
print(is_anagram('abcdef', 'abcdefg'))  # False
print(is_anagram('abcdef', 'abcdeg'))   # False

Ce programme crée des dictionnaires qui mappent chaque caractère de chaque chaîne à son nombre d’occurrences dans la chaîne. La fonction

retourne

si ces dictionnaires sont égaux, et

sinon.