Introduction à la Manipulation des Chaînes de Caractères

Les chaînes de caractères (strings) sont un type de données fondamental en Python, utilisées pour représenter du texte. Elles sont immuables, ce qui signifie qu'une fois créées, elles ne peuvent pas être modifiées directement. Cependant, Python offre une multitude de fonctions et de méthodes pour créer de nouvelles chaînes basées sur des existantes.

Extraction d'informations d'une URL

Il est courant d'avoir besoin d'extraire des identifiants ou d'autres fragmnets spécifiques d'une chaîne de caractères complexe, comme une URL. Plutôt que de s'appuyer sur des indices fixes, ce qui rend le code fragile, il est préférable d'utiliser des méthodes de division (split) ou de suppression (rstrip).

url_produit = "https://www.monboutique.com/categorie/electronique/produit_smart_tv_id-45678.html"

# Méthode 1: Utilisation de split et rstrip
segments_url = url_produit.split('/')
nom_fichier_complet = segments_url[-1] # 'produit_smart_tv_id-45678.html'
partie_sans_extension = nom_fichier_complet.rstrip('.html') # 'produit_smart_tv_id-45678'
identifiant_produit = partie_sans_extension.split('id-')[-1] # '45678'
print(f"ID produit extrait: {identifiant_produit}")

# Méthode 2: Extraction d'une date d'une autre URL structurée
url_rapport = "https://data.entreprise.com/rapports/ventes_mensuelles_2023-11.pdf"
nom_rapport = url_rapport.split('/')[-1] # 'ventes_mensuelles_2023-11.pdf'
date_rapport_str = nom_rapport.rstrip('.pdf').split('_')[-1] # '2023-11'
print(f"Date du rapport extraite: {date_rapport_str}")

Construction de chaînes de caractères

La concaténation de chaînes est une opération fréquente. Python 3 privilégie l'utilisation des f-strings (chaînes formatées) pour une syntaxe plus lisible et performante.

protocole = "https://"
domaine = "api.exemple.com"
version_api = "v2"
ressource = "utilisateurs"
parametre_id = "123"

# Construction d'une URL d'API complète avec des f-strings
url_api = f"{protocole}{domaine}/{version_api}/{ressource}/{parametre_id}"
print(f"URL d'API générée: {url_api}")

Génération d'une série d'URLs

Il est souvent nécessaire de générer dynamiquement plusieurs URLs, par exemple pour parcourir des pages de résultats ou des articles.

prefixe_base_articles = "https://monblogtech.info/archives/categorie/programmation/page-"
suffixe_html = ".html"
nombre_pages_a_generer = 4

print("Génération de liens d'articles par page:")
for index_page in range(1, nombre_pages_a_generer + 1):
    url_page_complete = f"{prefixe_base_articles}{index_page}{suffixe_html}"
    print(url_page_complete)

Fonctions intégrées pour les chaînes de caractères : strip, split, count

Python fournit des méthodes puissantes pour manipuler les chaînes, telles que strip() pour supprimer les espaces ou des caractères spécifiques aux extrémités, split() pour diviser une chaîne en une liste de sous-chaînes, et count() pour dénombrer les occurrences d'une sous-chaîne.

Extraction avec rstrip et split

Ces méthodes peuvent être chaînées pour des extractions complexes.

identifiant_complet = "code-projet-ALPHA-2023.zip   " # Contient des espaces à la fin
# On veut extraire "ALPHA"
# 1. Supprimer les espaces et l'extension ".zip"
sans_extension_et_espaces = identifiant_complet.strip().rstrip('.zip') # "code-projet-ALPHA-2023"
# 2. Diviser par le tiret et prendre la partie désirée
code_alpha = sans_extension_et_espaces.split('-')[2] # "ALPHA"
print(f"Code du projet extrait: {code_alpha}")

Comptage d'occurrences de mots

La méthode count() permet de trouver combien de fois une séquence de caractères apparaît dans une chaîne. Pour un comptage de mots robuste, il est souvent utile de normaliser la casse du texte.

corpus_texte = """Le Python est un langage de programmation.
Beaucoup de développeurs utilisent Python pour des applications variées.
Apprendre Python est un excellent choix. PYTHON est polyvalent.
"""

mot_a_compter = "python"
# Pour un comptage insensible à la casse, convertir tout le corpus en minuscules
corpus_normalise = corpus_texte.lower()
nombre_apparitions = corpus_normalise.count(mot_a_compter)

print(f"Le mot '{mot_a_compter}' apparaît {nombre_apparitions} fois dans le texte.")

Décomposition d'une chaîne en mots

La méthode split() sans argument sépare une chaîne par les espaces (tous les types d'espaces, incluant tabulations et retours à la ligne) et supprime les chaînes vides résultantes. Avec un argument, elle utilise ce dernier comme délimiteur.

phrase_simple = "Voici une phrase avec plusieurs mots."
mots_en_liste = phrase_simple.split()
print(f"Liste de mots (split par défaut): {mots_en_liste}")

# Exemple avec un délimiteur spécifique
liste_csv = "element1;element2;element3;element4"
elements_separes = liste_csv.split(';')
print(f"Éléments séparés par point-virgule: {elements_separes}")

Exploration des Types de Données Composés

Python propose plusieurs types de données composés ou collections pour organiser et stocker des groupes de données : les listes (list), les tuples (tuple), les dictionnaires (dict) et les ensembles (set). Chacun a des propriétés et des cas d'utilisation spécifiques.

Itération sur une chaîne de caractères

Bien que les chaînes soient des types de données atomiques, elles se comportent comme des séquences d'éléments (caractères) et sont donc itérables.

chaine_exemple = "Hello"
print("Parcours d'une chaîne de caractères:")
for lettre in chaine_exemple:
    print(lettre)

Itération sur une liste

Les listes sont des collections ordonnées et mutables d'éléments. Elles sont très flexibles et peuvent contenir des éléments de différents types.

liste_fruits = ["pomme", "banane", "cerise", "datte"]
print("\nParcours d'une liste:")
for fruit in liste_fruits:
    print(fruit)

Itération sur un tuple

Les tuples sont similaires aux listes, mais ils sont immuables. Une fois créés, leurs éléments ne peuvent pas être modifiés, ajoutés ou supprimés. Ils sont souvent utilisés pour des collections d'éléments dont l'ordre et le contenu ne devraient pas changer.

tuple_parametres = ("localhost", 8080, True)
print("\nParcours d'un tuple:")
for parametre in tuple_parametres:
    print(parametre)

Itération sur un dictionnaire

Les dictionnaires stockent des paires clé-valeur. Les clés sont uniques et immuables, tandis que les valeurs peuvent être de n'importe quel type et peuvent être modifiées. L'itération par défaut sur un dictionnaire parcourt ses clés.

infos_utilisateur = {
    "identifiant": "utilisateur_alpha",
    "email": "alpha@exemple.com",
    "role": "administrateur",
    "actif": True
}

print("\nParcours d'un dictionnaire:")
print("--- Clés:")
for cle in infos_utilisateur.keys():
    print(cle)

print("--- Valeurs:")
for valeur in infos_utilisateur.values():
    print(valeur)

print("--- Paires clé-valeur (items):")
for cle, valeur in infos_utilisateur.items():
    print(f"{cle}: {valeur}")

Itération sur un ensemble (Set)

Les ensembles sont des collecitons non ordonnées d'éléments uniques. Ils sont utiles pour les opérations mathématiques d'ensembles comme l'union, l'intersection, ou pour éliminer les doublons d'une liste.

ensemble_chiffres_premiers = {2, 3, 5, 7, 11}
print("\nParcours d'un ensemble (Set):")
for chiffre in ensemble_chiffres_premiers:
    print(chiffre)

Synthèse : Similarités et Différences entre Listes, Tuples, Dictionnaires et Ensembles

Similarités

• Tous ces types permettent de stocker des colllections d'éléments.
• Ils peuvent généralement contenir des éléments de types de données hétérogènes (sauf pour les clés de dictionnaire et les éléments d'ensemble qui doivent être hachables).
• Ils peuvent être convertis les uns aux autres (par exemple, une liste en tuple, une liste en ensemble, etc., sous certaines conditions).
• Les listes et les tuples peuvent être imbriqués les uns dans les autres.

Différences Clés

• Mutabilité :
  • Listes : Mutables (leur contenu peut être modifié après création).
  • Tuples : Immuables (leur contenu ne peut pas être modifié après création).
  • Dictionnaires : Mutables (les paires clé-valeur peuvent être ajoutées, supprimées ou modifiées, mais les clés elles-mêmes doivent être immuables).
  • Ensembles : Mutables (des éléments peuvent être ajoutés ou supprimés, mais les éléments eux-mêmes doivent être immuables).
• Ordre :
  • Listes et Tuples : Ordonnés (les éléments conservent l'ordre dans lequel ils ont été insérés, et peuvent être accédés par indice).
  • Dictionnaires : Ordonnés à partir de Python 3.7 (les clés conservent l'ordre d'insertion). Avant Python 3.7, ils étaient non ordonnés.
  • Ensembles : Non ordonnés (les éléments n'ont pas d'ordre défini et ne peuvent pas être accédés par indice).
• Doublons :
  • Listes et Tuples : Autorise les éléments en double.
  • Dictionnaires : Les clés doivent être uniques (les valeurs peuvent être en double).
  • Ensembles : N'autorise pas les éléments en double (chaque élément est unique).
• Accès aux éléments :
  • Listes et Tuples : Accès par indice numérique (ma_liste[0]).
  • Dictionnaires : Accès par clé (mon_dictionnaire['ma_cle']).
  • Ensembles : Accès uniquement par itération (pas d'indice ni de clé pour un élément individuel).