Introduction

Les fonctionnalites de manipulation de chaines de caracteres en Python sont essentielles pour tout developpeur. Que vous travailliez sur des rapports, des interfaces en ligne de commande, ou des fichiers de donnees, savoir aligner et formater du texte est une competence fondamentale.

Dans cet article, nous allons explorer en profondeur les methodes str.ljust() et str.rjust(), deux outils puissants pour l’alignement de texte. Nous couvrirons egalement les fonctions str.startswith() et str.endswith() pour la verification de motifs, ainsi que la conversion entre chaines et bytes Unicode. Enfin, nous aborderons l’utilisation de boucles dans les fonctions et l’importation de modules.

Ces techniques sont particulierement utiles lorsque vous devez :

• Creer des tableaux alignes dans la console
• Generer des rapports textuels formates
• Traiter des fichiers de configuration
• Afficher des donnees de maniere lisible

Les methodes str.ljust() et str.rjust()

Les methodes str.ljust() et str.rjust() sont des outils essentiels pour l’alignement de texte en Python. Elles permettent de justifier une chaine a gauche ou a droite en ajoutant des caracteres de remplissage.

Syntaxe de base

# str.ljust(width, fillchar=' ')
# str.rjust(width, fillchar=' ')

texte = "Python"
print(texte.ljust(10))      # 'Python    ' (espaces a droite)
print(texte.rjust(10))      # '    Python' (espaces a gauche)
print(texte.ljust(10, '-')) # 'Python----' (tirets a droite)
print(texte.rjust(10, '0')) # '0000Python' (zeros a gauche)

Exemple pratique : tableau de donnees

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189, 305)
}

print("Route    Miles    Km")
print("-" * 25)

for road, length in interstates_lengths.items():
    miles, kms = length
    print('{} -> {} mi. ({} km)'.format(
        str(road).rjust(4),
        str(miles).ljust(4),
        str(kms).ljust(4)
    ))

La methode str.center()

En complement de ljust() et rjust(), Python offre aussi center() pour centrer le texte :

titre = "Rapport Annuel"
print(titre.center(40, '='))
# =============Rapport Annuel=============

Les fonctions str.startswith() et str.endswith()

Les fonctions str.startswith() et str.endswith() sont utilisees pour tester si une chaine commence ou se termine par un certain motif. Elles sont extremement utiles pour la validation de donnees et le filtrage de fichiers.

Utilisation basique

s = "This is a test string."
print(s.startswith("T"))    # True
print(s.startswith("Thi"))  # True
print(s.startswith("thi"))  # False (sensible a la casse)

print(s.endswith('.'))      # True
print(s.endswith('!'))      # False
print(s.endswith('string.')) # True

Verification avec tuples

Ces methodes acceptent aussi des tuples pour verifier plusieurs motifs :

fichier = "document.pdf"

# Verifier si c'est un fichier image
extensions_images = ('.jpg', '.png', '.gif', '.bmp')
print(fichier.endswith(extensions_images))  # False

# Verifier si c'est un document
extensions_docs = ('.pdf', '.doc', '.docx', '.txt')
print(fichier.endswith(extensions_docs))    # True

Arguments start et end

url = "https://www.example.com/page"

# Verifier a partir d'une position specifique
print(url.startswith("www", 8))     # True (commence a l'index 8)
print(url.startswith("example", 8, 20))  # False

Conversion entre chaines et bytes Unicode

Dans Python 3, les chaines (str) et les bytes (bytes) sont des types distincts. Comprendre la conversion entre ces types est essentiel pour le traitement de donnees.

Encodage et decodage

# Encodage : str -> bytes
texte = "Cafe resume"
encoded = texte.encode('utf-8')
print(encoded)  # b'Caf\xc3\xa9 r\xc3\xa9sum\xc3\xa9'
print(type(encoded))  # <class 'bytes'>

# Decodage : bytes -> str
decoded = encoded.decode('utf-8')
print(decoded)  # Cafe resume
print(type(decoded))  # <class 'str'>

Gestion des erreurs d’encodage

texte = "Cafe resume"

# Differentes strategies de gestion d'erreurs
print(texte.encode('ascii', errors='ignore'))   # b'Caf rsum'
print(texte.encode('ascii', errors='replace'))  # b'Caf? r?sum?'
print(texte.encode('ascii', errors='xmlcharrefreplace'))  # b'Café résumé'

Exemple avec fichiers

# Lecture de fichier avec encodage specifique
with open('fichier.txt', 'r', encoding='utf-8') as f:
    contenu = f.read()

# Ecriture avec encodage
with open('sortie.txt', 'w', encoding='utf-8') as f:
    f.write("Donnees avec accents : eaiou")

Utilisation de boucles dans les fonctions

Les boucles combinees avec return permettent de creer des fonctions de recherche efficaces.

Pattern de recherche avec retour anticipe

def trouver_premier(params, cible):
    """Trouve le premier element correspondant a la cible."""
    for index, value in enumerate(params):
        print(f'Verification de {value} a l\'index {index}')
        if value == cible:
            return f'Trouve {cible} a l\'index {index}'
    return f'{cible} non trouve dans la liste'

resultat = trouver_premier([5, 3, 1, 2, 8, 9], 1)
print(resultat)

Fonction avec multiple conditions

def analyser_liste(nombres):
    """Analyse une liste et retourne des statistiques."""
    if not nombres:
        return "Liste vide"

    positifs = []
    negatifs = []

    for n in nombres:
        if n > 0:
            positifs.append(n)
        elif n < 0:
            negatifs.append(n)

    return {
        'positifs': len(positifs),
        'negatifs': len(negatifs),
        'zeros': len(nombres) - len(positifs) - len(negatifs)
    }

stats = analyser_liste([1, -2, 0, 3, -4, 5, 0])
print(stats)  # {'positifs': 3, 'negatifs': 2, 'zeros': 2}

Importation de modules

L’importation de modules est essentielle pour etendre les fonctionnalites de Python.

Differentes methodes d’importation

# Import complet du module
import random
print(random.randint(1, 10))

# Import de fonctions specifiques
from math import sin, cos, pi
print(sin(pi / 2))  # 1.0

# Import avec alias
import numpy as np
import pandas as pd

# Import de tout (a eviter en general)
from os.path import *

Bonnes Pratiques

Pour l’alignement de texte

1. Utilisez des constantes pour les largeurs :

LARGEUR_NOM = 20
LARGEUR_PRIX = 10

def formater_produit(nom, prix):
    return f"{nom.ljust(LARGEUR_NOM)}{str(prix).rjust(LARGEUR_PRIX)}"

2. Preferez les f-strings modernes pour l’alignement :

nom = "Python"
print(f"{nom:<10}")  # Equivalent a ljust(10)
print(f"{nom:>10}")  # Equivalent a rjust(10)
print(f"{nom:^10}")  # Equivalent a center(10)

3. Utilisez str.format() pour les cas complexes :

template = "{nom:<20} {prix:>10.2f} EUR"
print(template.format(nom="Article", prix=19.99))

Pour les verifications de chaines

1. Utilisez des tuples pour les verifications multiples :

# Bon
if fichier.endswith(('.py', '.pyw', '.pyx')):
    print("Fichier Python")

# Moins bon
if fichier.endswith('.py') or fichier.endswith('.pyw'):
    print("Fichier Python")

2. Normalisez avant de comparer :

def est_fichier_python(nom):
    return nom.lower().endswith(('.py', '.pyw', '.pyx'))

Pieges Courants

Piege 1 : Largeur insuffisante

texte = "Python est genial"
print(texte.ljust(5))  # Retourne la chaine originale, pas de troncature !
# Resultat: 'Python est genial'

Solution : Verifiez ou tronquez manuellement si necessaire :

def ljust_tronque(texte, largeur):
    return texte[:largeur].ljust(largeur)

Piege 2 : Caractere de remplissage multi-caracteres

# Ceci provoque une erreur !
try:
    "test".ljust(10, '--')
except TypeError as e:
    print(f"Erreur: {e}")  # The fill character must be exactly one character long

Piege 3 : Oubli de la sensibilite a la casse

url = "HTTPS://example.com"
print(url.startswith("https"))  # False !

# Solution
print(url.lower().startswith("https"))  # True

Piege 4 : Confusion entre str et bytes

texte_str = "Hello"
texte_bytes = b"Hello"

# Ceci echoue !
try:
    print(texte_str + texte_bytes)
except TypeError as e:
    print(f"Erreur: {e}")

# Solution : convertir au meme type
print(texte_str + texte_bytes.decode('utf-8'))

Conclusion

Les methodes d’alignement de texte ljust(), rjust() et center() sont des outils indispensables pour tout developpeur Python travaillant avec des donnees textuelles. Combinees avec les fonctions de verification startswith() et endswith(), elles permettent de creer des sorties formatees et de valider efficacement les donnees.

Points cles a retenir :

• ljust() ajoute des caracteres a droite (justification a gauche)
• rjust() ajoute des caracteres a gauche (justification a droite)
• startswith() et endswith() acceptent des tuples pour des verifications multiples
• La conversion entre str et bytes necessite une attention particuliere a l’encodage
• Les f-strings modernes offrent une syntaxe plus concise pour l’alignement

Maitrisez ces techniques et vous serez capable de produire des sorties console professionnelles et de manipuler efficacement vos donnees textuelles en Python !