Aller au contenu

Entrainement types sequences : tuple, list, str

str

Exercice : afficher le premier charactère d'une chaine

Implantez une fonction qui prends en entrée une chaîne de caractère non vide et retourne son premier charactère.

def premier_caractere(s):
    """ s une chaîne, s != ""
    affiche le premier caractère de s

    premier_caractère("abc") vaut "a"
    """
    pass
  • Utilisez l'opérateur [].
  • Les caractères dans une chaine comm
def premier_caractere(s):
    """ s une chaîne, s != ""
    affiche le premier caractère de s

    premier_caractere("abc") vaut a
    """
    return s[0]

Exercice : i-ème caractère d'une chaîne

Implantez la fonction suivante : 

def ieme_caractere(s, i):
    """s une chaine, i un entier, i > 0
    retourne le i-ème caractère de s

    ieme_charactere("abc", 2) vaut "c"
    """
    pass
  • Utilisez [i] pour accéder au caractère en position i dans une chaine.
def ieme_caractere(s, i):
    """s une chaine, i un entier, i > 0
    retourne le i-ème caractère de s

    ieme_charactere("abc", 2) vaut "c"
    """
    return s[i]

Appelez la fonction de la manière suivante :

ieme_charactere("abc", 8)

Ce code produit une erreur. Essayez de comprendre pourquoi.

  • La dernière ligne d'une erreur Python est généralement la meilleure pour comprendre l'erreur.
  • index veut dire indice. C'est un synomyme de position dans notre cas.
  • out of range veut dire hors de portée

Index out of range veut dire que l'on essaye d'accéder à une position qui n'est pas dans la chaîne.

Ici, notre chaîne comporte 3 caractères. Comme les indices commencent à zéro, la position la plus grande dans une chaîne de 3 caractères est 2. Donc, quand on essaie d'accéder à la position 8, cette position n'existe pas dans la chaîne, ce qui génère une erreur.

Changez la spécification et ajoutez une assertion pour tenir compte de ce prérequis : la position doit être strictement inférieure à la longueur de la chaîne.

La longueur d'une chaîne se s'obtient avec la fonction len, qui prends la chaîne en paramètre. len("abc") vaut 3.

def ieme_caractere(s, i):
    """s une chaine, i un entier, i > 0, i < len(s)
    retourne le i-ème caractère de s

    ieme_charactere("abc", 2) vaut "c"
    """
    assert i < len(s)

    return s[i]

Les accès en dehors des positions sont une source fréquente d'erreurs en programmation, il faut donc garder cette possibilité en tête pour débugger plus vite !

Exercice : tableau d'itération

Observez le code suivant :

s = "chaiiiine"
i = 0
r = ""
while i < 5:
    r = r + s[i]
    i = i + 1
print(r)

Dressez un tableau qui à chaque ligne récapitule les valeurs de r et i à chaque fois que la condition de la boucle est testée.

Voici le début du tableau

i r
0 ""
1 "c"
2 "ch"
i r commentaire
0 "" Ici on rentre dans la boucle
1 "c" Premier tour
2 "ch"
3 "cha"
4 "chai"
5 "chain" Ici on sort de la boucle

Exercice : inverser une chaîne

Ecrivez une fonction inverse, qui prends en paramètre une chaîne, et retourne une chaîne avec les caractères en ordre inverse

def inverse(s):
    """ s une chaine
    retourne une chaine contenant les caractères de s en ordre inverse

    inverse("abcdef") vaut "fedcba"
    """
    pass

Observez la fonction suivante et adaptez-là : 

def copie(s):
    """ s une chaine
    retourne une copie de s

    copie("abcdef") vaut "abcdef"
    """
    cop = ""
    ## pour chaque caractère dans la chaine d'origine
    for c in s:
        cop = cop + c ## on l'ajoute à la FIN de la copie 
    return cop

N'hesitez pas à faire un tableau d'itération pour mieux comprendre cette fonction.

def inverse(s):
    """ s une chaine
    retourne une chaine contenant les caractères de s en ordre inverse

    inverse("abcdef") vaut "fedcba"
    """
    inv = ""
    ## pour chaque caractère dans la chaine d'origine
    for c in s:
        inv = c + inv ## on l'ajoute à au DEBUT de la copie inverse
    return inv

Exercice : double consonnes

Implantez la fonction suivante: 

def double_consonne(s):
    """s une chaine contenant un mot de français écrit sans accent.
    retourne True si s contient une double consonne. False sinon.

    exemple:
    double_consonne("contrepetrie") retourne False
    double_consonne("appeller") retourne True
    double_consonne("attaque") retourne True
    """
    pass

Commencez par implanter la fonction suivante :

def contient_double(c, s):
    """c une chaine contenant un seul caractère. s une chaîne.
    retourne True si s contient c + c, False sinon.

    exemple :
    contient_double("l", "appeller") retourne True
    contient_double("t", "appeller") retourne False
    """
    pass

Utilisez l'opérateur in pour implanter la fonction contient_double.

Vous pouvez implanter la fonction double_consonne en utilisant une boucle for pour parcourir la chaine à tester, et donc tester chaque caractère.

def contient_double(c, s):
    """c une chaine contenant un seul caractère. s une chaîne.
    retourne True si s contient c + c, False sinon.

    exemple :
    contient_double("l", "appeller") retourne True
    contient_double("t", "appeller") retourne False
    """
    return "c" + "c" in s

def double_consonne(s):
    """s une chaine contenant un mot de français écrit sans accent.
    retourne True si s contient une double consonne. False sinon.

    exemple:
    double_consonne("contrepetrie") retourne False
    double_consonne("appeller") retourne True
    double_consonne("attaque") retourne True
    """
    trouve = False 
    for c in s:
        if double_consonne(c,s):
            trouve = True
    return trouve

def contient_double(c, s):
    """c une chaine contenant un seul caractère. s une chaîne.
    retourne True si s contient c + c, False sinon.

    exemple :
    contient_double("l", "appeller") retourne True
    contient_double("t", "appeller") retourne False
    """
    return "c" + "c" in s


def double_consonne(s):
    """s une chaine contenant un mot de français écrit sans accent.
    retourne True si s contient une double consonne. False sinon.

    exemple:
    double_consonne("contrepetrie") retourne False
    double_consonne("appeller") retourne True
    double_consonne("attaque") retourne True
    """
    for c in s :
        if contient_double(c, s):
            ## On peut retourner directement dans une boucle,
            ## Attention toutefois, ça peut baisser la lisibilité 
            ## du code si la boucle est compliquée
            return True

On aurait aussi pu ne pas utiliser de fonction intermédiaire. Le code est alors plus rapide à écrire, mais on perds alors l'expressivité qui était donnée par le nom de la fonction itermédiaire

def double_consonne(s):
    """s une chaine contenant un mot de français écrit sans accent.
    retourne True si s contient une double consonne. False sinon.

    exemple:
    double_consonne("contrepetrie") retourne False
    double_consonne("appeller") retourne True
    double_consonne("attaque") retourne True
    """
    for c in s :
        if c + c in s:
            ## On peut retourner directement dans une boucle,
            ## Attention toutefois, ça peut baisser la lisibilité 
            ## du code si la boucle est compliquée
            return True

TODO (prof) ajout version avec tests !

Exercice : i premiers caractères

Implantez la fonction suivante:

def i_premiers(s, i):
    """s une chaine, i un entier, i > 0 , i < len(s)
    retourne les i premiers caractères de s

    i_premiers("abcd", 2) vaut "ab"
    """
    assert i < len(s)
    pass

Il vous faudra sans doute utiliser l'opérateur [] et des :. Regardez le tableau dans le cours pour la syntaxe exacte.

def i_premiers(s, i):
    """s une chaine, i un entier, i > 0 , i < len(s)
    retourne les i premiers caractères de s

    i_premiers("abcd", 2) vaut "ab"
    """
    assert i < len(s)
    return s[:i]

Exercice : deux deux

Implantez la fonction suivante : 

def deux_deux(a, b):
    """a, b des chaines de longueur 4
    retourne une chaine composée des deux premiers caractères de a, et des deux derniers caractères de b

    deux_deux("abcd", "efgh") vaut "abgh"
    """
    assert len(a) == 4 and len(b) == 4
    pass

Vous devrez utiliser l'opérateur [] et des :. regardez le tableau dans le cours pour la syntaxe exacte.

Vous aurez aussi besoin de l'opérateur +.

def deux_deux(a, b):
    """a, b des chaines de longueur 4
    retourne une chaine composée des deux premiers caractères de a, et des deux derniers caractères de b

    deux_deux("abcd", "efgh") vaut "abgh"
    """
    assert len(a) == 4 and len(b) == 4
    return a[:2] + b[3:]

Alternativement, on aurait pu partir de la fin. de b, en utilisant un indice négatif

def deux_deux(a, b):
    """a, b des chaines de longueur 4
    retourne une chaine composée des deux premiers caractères de a, et des deux derniers caractères de b

    deux_deux("abcd", "efgh") vaut "abgh"
    """
    assert len(a) == 4 and len(b) == 4
    return a[:2] + b[-2:]

Exercice : moite-moite

Implantez la fonction suivante:

def moite_moite(a, b):
    """a, b des chaînes non vides
    retourne une chaîne composée de la première moitié de a, et de la seconde moitié de b


    moite_moite("abcdef", "ghijk") vaut "abcjk"
    """
    assert a != "" et b != ""
    pass

La fonction len permet de connaître la longueur d'une chaîne.

La longueur d'une chaine est un entier.

On peut diviser les entiers par 2.

def moite_moite(a, b):
    """a, b des chaînes non vides
    retourne une chaîne composée de la première moitié de a, et de la seconde moitié de b


    moite_moite("abcdef", "ghijk") vaut "abcjk"
    """
    assert a != "" et b != ""
    moit_a = len(a) / 2 ## indice à la moitié de a
    moit_b = len(b) / 2 ## incice à la moitié de b
    return a[:moit_a] + b[:moit_b]

tuple

Exercice : premier élément d'un tuple

Implantez une fonction qui prends en entier un tuple non vide et retourne son premier élément : 

def premier_element(t):
    """t un tuple non vide
    retourne le premier élément de t

    Exemple :
    premier_element((10, 20, 30)) retourne 10
    """
    pass

utilisez l'opérateur []

def premier_element(t):
    """t un tuple non vide
    retourne le premier élément de t

    Exemple :
    premier_element((10, 20, 30)) retourne 10
    """
    assert t != () ##on vérifie que le tuple est non vide
    return t[0]

Exercice : i-ème élément d'un tuple

Implantez une fonction qui retourne le i-eme élément d'un tuple :

def ieme_element(t, i):
    """t un tuple, len(t) > i
    i un entier, i >= 0
    retourne l'élement de t en position i

    Exemple :
    ieme_element((10, 20, 30, 40), 2) retourne 30 
    """
    pass

Utilisez [i] pour accéder à l'éléménet en position i dans un tuple

def ieme_element(t, i):
    """t un tuple, len(t) > i
    i un entier, i >= 0
    retourne l'élement de t en position i

    Exemple :
    ieme_element((10, 20, 30, 40), 2) retourne 30 
    """
    assert i >= 0
    assert len(t) > i
    return t[i]

Exercice : somme d'un tuple

Implantez la fonction suivante : 

def somme(t):
    """t un tuple non vide ne contenant que des entiers
    retourne la somme des éléments de t

    Exemple:
    somme((1,2,3,4,5)) = 15
    """
    pass

Utilisez une boucle for. Il vous faudra aussi utiliser une variable supplémentaire, initialisée à 0.

def somme(t):
    """t un tuple non vide ne contenant que des entiers
    retourne la somme des éléments de t

    Exemple:
    somme((1,2,3,4,5)) = 15
    """
    s = 0
    for e in t:
        s = s + e
    return s

Exercice : est-ce qu'une matière est disponible ?

Implantez un programme qui demande à un utilisateur de rentrer le nom d'une matière, puis dit à l'utilisateur si la matière est disponible ("maths" ou "NSI" ou "SVT" ou "physique") ou non. Vous devez utilisez au maximum un if et un else.

Exemples de traces : 

Matière ? Histoire
Cette matière n'est pas disponible !

Matière: maths
Cette matière est disponible !

Utilisez un tuple (ou une list) pour stocker la liste des matières !

Utilisez in pour vérifier si une valeur est dans le tuple.

matieres = ("maths", "physique", "SVT", "NSI")

r = input("Matière ? ")
if r in matieres:
    print("Cette matière est disponible !")
else :
    print("Cette matière n'est pas disponible !")

list

Exercice : premier élément d'une list

Implantez une fonction qui prends en entier une list non vide et retourne son premier élément : 

def premier_element(l):
    """l une list non vide
    retourne le premier élément de l

    Exemple :
    premier_element([10, 20, 30]) retourne 10
    """
    pass

utilisez l'opérateur []

def premier_element(l):
    """l un tuple non vide
    retourne le premier élément de l

    Exemple :
    premier_element([10, 20, 30]) retourne 10
    """
    assert l != () ##on vérifie que le tuple est non vide
    return l[0]

Exercice : i-ème élément d'une list

Implantez une fonction qui retourne le i-eme élément d'une list :

def ieme_element(l, i):
    """l un tuple, len(l) > i
    i un entier, i >= 0
    retourne l'élement de l en position i

    Exemple :
    ieme_element([10, 20, 30, 40], 2) retourne 30 
    """
    pass

Utilisez [i] pour accéder à l'éléménet en position i dans une list

def ieme_element(t, i):
    """l un tuple, len(l) > i
    i un entier, i >= 0
    retourne l'élement de t en position i

    Exemple :
    ieme_element((10, 20, 30, 40), 2) retourne 30 
    """
    assert i >= 0
    assert len(l) > i
    return l[i]

Exercice : moyenne d'une list

Implantez la fonction suivante : 

def moy(l):
    """l une list non vide ne contenant que des entiers
    retourne la moyenne des éléments de l

    Exemple:
    moy([1,2,3,4,5]) retourne 3
    """
    pass

Utilisez une boucle for.

Rappel : la moyenne d'une séquence d'éléments est la somme des élements divisés par le nombre d'éléments. 

def moy(l):
    """l une list non vide ne contenant que des entiers
    retourne la moyenne des éléments de l

    Exemple:
    moy([1,2,3,4,5]) retourne 3
    """
    somme = 0
    for e in l:
        somme = somme + e
    return somme / len(l)

Mixte

Exercice : egalité entre list et tuple

Implémentez la fonction suivante :

def egal(t,l):
    """t un tuple 
    l une list
    retourne True si t contient les mêmes valeurs que l et dans le même ordre, False sinon

    Exemple:
    egal((1,2,3),[1,2,3]) retourne True
    egal((1,2,3),[1,2,3,4]) retourne False
    egal((1,2,3),[1,2,2]) retourne False
    """
    pass

Vous pouvez utiliser une boucle for ou while pour comparer les deux, mais cette solution est compliquée !

Sinon, vous pouvez transformer la list en tuple à l'aide de la fonction tuple

Ou encore, vous pouvez transformer le tuple en list avec la fonction list.

On transforme la list en tuple : 

def egal(t,l):
    """t un tuple 
    l une list
    retourne True si t contient les mêmes valeurs que l et dans le même ordre, False sinon

    Exemple:
    egal((1,2,3),[1,2,3]) retourne True
    egal((1,2,3),[1,2,3,4]) retourne False
    egal((1,2,3),[1,2,2]) retourne False
    """
    return t == tuple(l)

ou vice-versa, le tuple en list :

def egal(t,l):
    """t un tuple 
    l une list
    retourne True si t contient les mêmes valeurs que l et dans le même ordre, False sinon

    Exemple:
    egal((1,2,3),[1,2,3]) retourne True
    egal((1,2,3),[1,2,3,4]) retourne False
    egal((1,2,3),[1,2,2]) retourne False
    """
    return list(t) == l

Cette solution est beaucoup moins concise, et aussi plus difficile à écrire. La solution concise lui est donc préférable.

def egal(t,l):
    """t un tuple 
    l une list
    retourne True si t contient les mêmes valeurs que l et dans le même ordre, False sinon

    Exemple:
    egal((1,2,3),[1,2,3]) retourne True
    egal((1,2,3),[1,2,3,4]) retourne False
    egal((1,2,3),[1,2,2]) retourne False
    """
    if len(t) != len(l): ## les deux séquences ne sont pas de même longueur
        return False
    i = 0
    ## On va comparer 2 a 2 les éléments de t et l, dans l'ordre.
    ## tant qu'on trouve des éléments deux à deux égaux, on 
    ## continue, sinon on s'arrête.
    while i < len(t) and e[i] == l[i]: ##rappel, ici len(t) == len(l).
        i = i + 1
    ## ici, si i < len(t), alors on n'a pas parcouru tous les éléments, et 
    ## donc on est sorti de la boucle à cause d'une différence
    ## Si on a pas trouvé de différences (les séquences sont égales), 
    ## alors i == len(t)
    return i == len(t)

TODO (prof) ajouter un schéma ?

TP

TODO (prof) ajouter un TP ici