Traitements sur chaînes de caractères

def capitaliser(ch):
    if len(ch) == 0:
        return ch
    return ch[0].upper() + ch[1:].lower()

print(capitaliser("informaTIQUE"))   # Informatique
print(capitaliser(""))                # "" (cas limite)

Décomposition :

1. ch[0] → premier caractère.
2. .upper() → en majuscule.
3. ch[1:] → tout sauf le premier (slicing).
4. .lower() → tout en minuscules.
5. Concaténation avec +.

Cas limite à tester : chaîne vide. Si on l'oublie, ch[0] provoque une IndexError.

Version 1 — méthode native (idiomatique)

def nb_mots(phrase):
    return len(phrase.split())

print(nb_mots("Bonjour le monde"))            # 3
print(nb_mots("   Bonjour   le   monde   "))   # 3
print(nb_mots(""))                              # 0
print(nb_mots("   "))                           # 0

split() sans argument découpe automatiquement sur n'importe quel ensemble d'espaces (un ou plusieurs) et ignore les espaces en début/fin. C'est exactement ce qu'on veut.

Version 2 — boucle manuelle (sans méthode magique)

def nb_mots(phrase):
    """Sans utiliser split()."""
    nb = 0
    dans_mot = False
    
    for c in phrase:
        if c != " " and not dans_mot:
            nb = nb + 1
            dans_mot = True
        elif c == " ":
            dans_mot = False
    
    return nb

Principe. On utilise un drapeau dans_mot qui passe à True au début de chaque mot et à False quand on rencontre un espace. On incrémente nb uniquement quand on entre dans un nouveau mot.

Trace pour " AB CD " :

Résultat final : 2. ✓

Au bac, quelle version écrire ?

• En épreuve pratique sur machine : la version 1 (len(phrase.split())) est plus courte, plus lisible et acceptée par tous les correcteurs. Préférez-la quand vous êtes pressé.
• En épreuve théorique où le sujet demande l'algorithme détaillé : la version 2 montre que vous comprenez la mécanique. Les correcteurs y voient une preuve de maîtrise au-delà du « truc » de la méthode native.

Connaître les deux vous met à l'abri d'un sujet qui interdirait l'usage de split().

import keyword

# Liste exhaustive (35 mots) fournie par Python lui-même via le module
# `keyword`. On évite ainsi d'oublier des mots-clés (lambda, yield, async…).
# Si on devait l'écrire à la main au bac, voici les principaux :
MOTS_RESERVES_PRINCIPAUX = {
    "if", "elif", "else", "for", "while", "break", "continue",
    "def", "return", "lambda", "class",
    "True", "False", "None",
    "and", "or", "not", "in", "is",
    "import", "from", "as", "pass", "with", "try", "except",
}

def est_identifiant_valide(ch):
    # Règle 1 : au moins un caractère
    if len(ch) == 0:
        return False
    
    # Règle 2 : premier caractère lettre ou _
    premier = ch[0]
    if not (premier.isalpha() or premier == "_"):
        return False
    
    # Règle 3 : suivants alphanumériques ou _
    for c in ch[1:]:
        if not (c.isalnum() or c == "_"):
            return False
    
    # Règle 4 : pas un mot réservé Python
    if keyword.iskeyword(ch):
        return False
    
    return True

# Tests
print(est_identifiant_valide("nom_complet"))   # True
print(est_identifiant_valide("2eme"))           # False (commence par chiffre)
print(est_identifiant_valide("nom-complet"))    # False (tiret)
print(est_identifiant_valide("_total"))         # True
print(est_identifiant_valide("if"))             # False (mot réservé)
print(est_identifiant_valide(""))               # False (vide)
print(est_identifiant_valide("a"))              # True (un seul caractère)

Décomposition de l'algorithme :

1. Test de longueur. Cas limite n°1 : chaîne vide.
2. Premier caractère. On teste explicitement avec isalpha() et == pour _.
3. Caractères suivants. Boucle sur ch[1:] (tout sauf le premier), test isalnum() or == "_".
4. Mot réservé. Test final via keyword.iskeyword(ch) qui interroge la liste officielle Python — toujours à jour, jamais incomplète.

Pourquoi le module keyword ? Python définit officiellement 35 mots-clés (False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield). Les énumérer à la main expose à des oublis. keyword.iskeyword() interroge directement Python — robuste et future-proof.

Au bac : la fonction keyword.iskeyword() n'étant pas au programme, on accepte une liste à la main des mots-clés principaux (le set MOTS_RESERVES_PRINCIPAUX ci-dessus suffit). Le correcteur ne pénalise pas si vous oubliez nonlocal ou async.

Variante avec compréhension de liste (Python avancé) :

import keyword

def est_identifiant_valide(ch):
    if not ch or keyword.iskeyword(ch):
        return False
    if not (ch[0].isalpha() or ch[0] == "_"):
        return False
    return all(c.isalnum() or c == "_" for c in ch[1:])

all(...) retourne True si tous les éléments satisfont la condition. C'est élégant mais hors programme officiel 4ème.