TD 0 : Types de données, saisie, affichage et lecture de code

Corrigé

type(7)         # <class 'int'>
type(7.0)       # <class 'float'>
type("7")       # <class 'str'>
type(True)      # <class 'bool'>
type(7 == 7.0)  # <class 'bool'>

Les trois premieres lignes montrent que le meme nombre 7 s'ecrit de trois facons differentes selon ce qu'on veut en faire : calculer avec (int), calculer avec des decimales (float), ou l'afficher comme du texte (str).

La derniere ligne merite une seconde de reflexion. 7 == 7.0 est une comparaison, pas une valeur : Python l'evalue d'abord, obtient True, et c'est le type de True qui est affiche. La comparaison est vraie parce que Python compare les valeurs numeriques, pas les types.

Corrigé

10 / 2    # 5.0      float
10 // 2   # 5        int
10 % 3    # 1        int
2 ** 10   # 1024     int
7 / 7     # 1.0      float

Retenez la premiere et la derniere ligne : meme quand la division tombe rond, / produit un flottant. C'est voulu, pour que le type du resultat ne depende pas des valeurs : 10 / 2 et 10 / 3 renvoient tous deux un float.

10 % 3 vaut 1 car 10 = 3 × 3 + 1. Le couple // et % va souvent ensemble : l'un donne le quotient, l'autre le reste.

Corrigé

int("42")        # 42
int(3.9)         # 3      et non 4
int(-3.9)        # -3     et non -4
float("3.14")    # 3.14
str(7) + str(3)  # '73'   et non 10

int(3.9) vaut 3 : la partie decimale est coupee, purement et simplement. Pour -3.9, la troncature ramene vers zero, donc -3. Si vous vouliez arrondir, il fallait round(3.9), qui donne 4.

La derniere ligne illustre le fait que + ne fait pas la meme chose selon les types : entre deux nombres il additionne, entre deux chaines il colle. "7" + "3" donne "73".

Corrigé

L'erreur est :

TypeError: can only concatenate str (not "int") to str

Traduction : Python a recu "20" + 1. A gauche une chaine, a droite un entier. Il ne sait pas quoi en faire, et refuse de deviner.

La correction tient dans la conversion :

age = int(input("Quel est ton age ? "))
print("L'an prochain tu auras", age + 1)

On peut aussi convertir au moment du calcul, int(age) + 1, mais convertir tout de suite a la saisie est plus propre : ensuite age est un nombre partout dans le programme, et on n'y pense plus.

Corrigé

True + True    # 2
False * 7      # 0
bool(0)        # False
bool("")       # False
bool("False")  # True   !
bool(-3)       # True   !

bool("False") vaut True, et c'est logique une fois qu'on a compris la regle : "False" est une chaine de cinq caracteres, donc une chaine non vide, donc vraie. Le contenu du texte n'est jamais interprete. "0" est vrai lui aussi, pour la meme raison.

bool(-3) vaut True parce que la regle porte sur « different de zero », pas sur « positif ».

Corrigé

print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False
print(round(2.675, 2))    # 2.67   et non 2.68
print(round(2.5))         # 2      et non 3
print(round(3.5))         # 4

Les deux premieres lignes sont la meme histoire : 0,1 et 0,2 sont stockes approches, leur somme tombe juste a cote de 0,3.

round(2.675, 2) donne 2,67 parce que la valeur reellement stockee est 2,67499999... : Python arrondit correctement un nombre qui n'est deja plus tout a fait 2,675.

Les deux dernieres lignes relevent d'une autre regle. Sur un cas parfaitement a mi-chemin, Python arrondit vers le pair le plus proche : 2,5 donne 2, et 3,5 donne 4. Ce n'est pas un bug, c'est la norme IEEE 754, choisie pour que les erreurs ne s'accumulent pas toujours dans le meme sens sur de longues series.

Pour comparer deux flottants :

abs((0.1 + 0.2) - 0.3) < 1e-9   # True

Corrigé

Placons les indices :

  D   o   u   a   l   a
  0   1   2   3   4   5
 -6  -5  -4  -3  -2  -1

len(ville)    # 6
ville[0]      # 'D'
ville[-1]     # 'a'
ville[2:5]    # 'ual'   indices 2, 3, 4
ville[:3]     # 'Dou'
ville[3:]     # 'ala'

ville[2:5] renvoie trois caracteres et non quatre : la borne de droite est exclue. C'est deroutant au debut, mais cela rend une propriete tres pratique : s[:3] + s[3:] reconstitue toujours s, sans chevauchement ni trou.

Enfin, len("Yaoundé") depend de l'ecriture : si le « e » accentue est un seul caractere, la reponse est 7. Python compte les caracteres, pas les octets : un accent compte pour un.

Corrigé

nom = input("Comment t'appelles-tu ? ")
print(f"Bonjour {nom}, bienvenue sur PandaCodeur !")

Trois autres ecritures donnent le meme resultat :

print("Bonjour " + nom + ", bienvenue sur PandaCodeur !")
print("Bonjour", nom, ", bienvenue sur PandaCodeur !")   # espace parasite
print("Bonjour {}, bienvenue !".format(nom))

La deuxieme est a eviter : print insere un espace entre ses arguments, on obtiendrait Awa , avec un espace avant la virgule. La f-string n'a pas ce defaut et reste la plus lisible.

Corrigé

a = int(input("Premier nombre : "))
b = int(input("Deuxieme nombre : "))
print(f"{a} + {b} = {a + b}")

Remarquez qu'une f-string accepte un calcul entre accolades, pas seulement un nom de variable. {a + b} est evalue au moment de l'affichage.

Si vous aviez ecrit print(f"{a} + {b} = {a} + {b}"), vous auriez obtenu 12 + 7 = 12 + 7 : les accolades affichent la valeur, elles ne calculent que ce qu'on leur donne a calculer.

Corrigé

a b c
a-b-c
abc
debut >>> fin

Les trois premieres lignes montrent sep a l'oeuvre : l'espace par defaut, puis un tiret, puis rien du tout.

Les deux dernieres instructions ne produisent qu'une seule ligne. En remplacant end par " >>> ", le premier print n'envoie plus de retour a la ligne : l'affichage suivant continue sur la meme ligne.

C'est le reglage a connaitre quand on veut construire un affichage en plusieurs morceaux.

Corrigé

montant = 1234567.891
texte = f"{montant:,.2f}"            # '1,234,567.89'
texte = texte.replace(",", " ")      # '1 234 567.89'
texte = texte.replace(".", ",")      # '1 234 567,89'
print(texte, "FCFA")

L'ordre des deux replace est essentiel. En commencant par le point, on obtiendrait 1,234,567,89, et la conversion suivante transformerait aussi les separateurs de milliers : le montant deviendrait illisible.

En remplacant d'abord les virgules, il ne reste plus qu'un seul point dans la chaine, celui des decimales. On peut alors le convertir sans risque.

En une seule expression, avec un caractere intermediaire :

print(f"{montant:,.2f}".replace(",", " ").replace(".", ",") + " FCFA")

Corrigé

morceaux = input("Entrez deux nombres : ").split()
a = int(morceaux[0])
b = int(morceaux[1])
print("Somme :", a + b)
print("Produit :", a * b)

Version plus courte, avec un deballage direct :

a, b = input("Entrez deux nombres : ").split()
a, b = int(a), int(b)
print("Somme :", a + b)
print("Produit :", a * b)

Ou encore, en une ligne grace a map, qui applique int a chaque morceau :

a, b = map(int, input("Entrez deux nombres : ").split())

Les trois versions sont correctes. La premiere est la plus explicite, la derniere la plus courante chez les habitues.

Corrigé

print('Il a dit : "bonjour"')
print("Nom\tVille")
print("Awa\tDouala")
print(r"C:\Users\Awa")

Premiere ligne : en entourant d'apostrophes, les guillemets interieurs ne posent aucun probleme. On aurait aussi pu ecrire "Il a dit : \"bonjour\"", moins lisible.

Derniere ligne : le prefixe r (pour raw) desactive l'interpretation des antislashs. Sans lui, il aurait fallu les doubler : "C:\\Users\\Awa". Et attention, "C:\Users" sans precaution ne produit pas ce qu'on croit : \U a une signification particuliere et declenche une erreur.

C'est la raison pour laquelle les chemins Windows s'ecrivent presque toujours avec un r devant.

Corrigé

article = "Cahier"
quantite = 3
prix = 1500

print(f"Article   : {article}")
print(f"Quantite  : {quantite:>10}")
print(f"Prix unit.: {prix:>10}")
print(f"Total     : {quantite * prix:>10}")

Chaque nombre occupe dix colonnes, complete par des espaces a gauche : les chiffres des unites tombent donc tous les uns sous les autres, ce qui rend la colonne lisible.

Le total est calcule directement dans l'accolade. On aurait pu le ranger dans une variable avant, les deux se valent ici.

Pour aller plus loin, {prix:>10,} ajouterait en plus les separateurs de milliers.

Corrigé

9 5

Deroulons :

a = 5     # a vaut 5
b = a     # b recoit la valeur actuelle de a, c'est-a-dire 5
a = 9     # a vaut maintenant 9 ; b n'a pas bouge
print(a, b)   # 9 5

L'erreur serait de lire b = a comme « b suit a ». Non : c'est une photographie, prise une fois, a cet instant precis. La ligne suivante change a sans toucher a la photo.

Gardez ce resultat en tete, l'exercice 18 raconte une histoire tres differente avec une liste.

Corrigé

8 3

Le detail de la deuxieme ligne :

x, y = y, x
#      ^^^^  evalue en premier : (8, 3) est mis de cote
# puis distribue : x recoit 8, y recoit 3

Dans beaucoup de langages, cet echange exige une variable tampon :

t = x
x = y
y = t

Python s'en passe parce que le membre de droite est integralement evalue avant la moindre affectation. Les anciennes valeurs sont deja en securite dans un couple temporaire quand x est ecrase.

Corrigé

6

Ligne par ligne :

n = 10          # n = 10
n += 5          # n = 10 + 5  = 15
n *= 2          # n = 15 * 2  = 30
n -= 3          # n = 30 - 3  = 27
n //= 4         # n = 27 // 4 = 6     (et non 6.75)
print(n)        # 6

La derniere ligne est le piege : //= fait une division entiere. 27 divise par 4 donne 6 reste 3, on garde 6.

Avec /= a la place, n vaudrait 6.75 et changerait de type au passage, devenant un float.

Corrigé

[1, 2, 3, 4]
[1, 2, 3, 4]

Les deux affichages sont identiques, et beaucoup de debutants ne s'y attendent pas apres avoir vu l'exercice 15.

La difference tient au type. Dans l'exercice 15, a = 9 reaffectait le nom a a une autre valeur, sans toucher a l'ancienne. Ici, b.append(4) ne reaffecte rien : il modifie l'objet lui-meme, et cet objet est celui que a designe aussi.

a = [1, 2, 3]
b = a[:]          # copie reelle
b.append(4)
print(a)          # [1, 2, 3]
print(b)          # [1, 2, 3, 4]

On peut verifier le partage avec id(), qui donne l'adresse de l'objet : dans le premier cas id(a) == id(b) est vrai, dans le second il est faux.

Corrigé

10

Le deroulement :

2 + 3 * 4 ** 2 // 5 - 1

4 ** 2   -> 16        la puissance d'abord
2 + 3 * 16 // 5 - 1

3 * 16   -> 48        puis * et //, de gauche a droite
2 + 48 // 5 - 1

48 // 5  -> 9
2 + 9 - 1

2 + 9    -> 11        enfin + et -
11 - 1   -> 10

Le point ou l'on se trompe le plus souvent est 3 * 4 ** 2 : la puissance s'applique a 4 seul, pas a 3 * 4. Le resultat est 48 et non 144.

Notez au passage que ** s'associe a droite : 2 ** 3 ** 2 vaut 2 ** 9 = 512, et non 8 ** 2 = 64.

Corrigé

ababab
6
--------------------
555

"ab" * 3 donne "ababab", six caracteres.

"-" * 20 est la facon habituelle de tracer une ligne de separation : bien plus court que d'ecrire vingt tirets a la main, et plus facile a ajuster.

La derniere ligne affiche 555 et non 15. Ici "5" est du texte : il est repete trois fois. Pour obtenir 15, il fallait convertir : int("5") * 3.

Enfin, "ab" * 0 donne la chaine vide, et un facteur negatif aussi : aucune erreur n'est levee.