Type de variables en Python - Seconde

Bonjour. J'ouvre ce topic pour avoir vos avis sur un point précis des aménagements de Seconde. Comme beaucoup de profs de maths, je suis à la base une buse en informatique mais j'essaye de me former du mieux que je peux pour après former du mieux que je peux les élèves puisqu'on nous demande de le faire (je ne cherche pas ici à relancer le débat si c'est bien ou pas...)

On nous demande de parler spécifiquement d'entiers, flottants et de chaînes de caractères. La première chose que j'essaye de faire sur des domaines que je ne maitrise absolument pas, c'est de regarder les activités, cours et exercices qui sont proposés aux élèves dans les manuels, je les fais et essaye de comprendre où on veut en venir avec le recul de mes années d'expérience d'enseignant.

Peut être que certains ont été destinataires comme moi d'un mail de l'édition Didier qui proposait des activités sur l'algorithmique 2017 en complément du Math'X. Je m'y suis penché et je reconnais que pour moi les activités, cours et exercices sont plutôt bien cadrés dans l'ensemble (à destination des élèves j'entends, sans doute insuffisant pour un prof!)

Concernant le type de variables, ils proposent une activité introductive visant à comprendre qu'un nombre entier naturel peut s'écrire sous la forme de puissances de 2 pour embrayer sur l'écriture binaire. Au début, je n'ai pas forcément vu où on voulait en venir puisque les aménagements n'en parlaient pas.
J'ai ensuite vu le cours (compréhensible pour un élève à partir du moment où on a fait l'activité introductive avant) où il est expliqué brièvement que les entiers négatifs et les nombres décimaux peuvent aussi être représentés en binaire (et c'est comme cela que l'ordinateur fait) et sur un exemple on comprend bien qu'il est difficile de représenter les décimaux et qu'on doit se contenter d'une approximation en écriture binaire d'un nombre décimal. Il est nécessaire d'avoir compris ça pour comprendre ensuite pourquoi si on entre sur Python

a=2.8
b=1.5
print(a*b)

on obtient 4.199999999 et pas 4.2 (et ainsi mieux comprendre la notion de flottant)

Du coup, pensez vous qu'il faille (ou qu'on puisse) introduire les nombres flottants de la sorte? Ca me gênerait de ne pas pouvoir expliquer correctement pourquoi le logiciel affiche 4.199999999 et pas 4.2

Je pense que pour correctement programmer, il faut avoir bien compris les types de variable et sans doute que ce pré-requis (qui demande encore beaucoup de temps du coup dans un programme toujours plus délirant en terme de lourdeur!) est essentiel.

Qu'en pensez vous?

Oui, le programme est un peu bancal : les flottants ne sont pas à étudier en tant que tels, mais c'est quand même ce qu'on manipule, et un élève un minimum curieux ne peut qu'interroger son professeur sur les bizarreries qui en découlent. Un collègue a écrit un article à destination des professeurs de seconde : https://www.yannsalmon.fr/informatique-en-seconde-que-savoir-sur-les-flottants/

Si le livre cité dit que les nombres décimaux peuvent être représentés en binaire, c'est une grosse connerie si par là on entend les flottants (il existe d'autres représentations binaires des nombres mais elles sont peu usitées) : par exemple 0.1 est un décimal mais non représentable en flottant, on n'a pas besoin d'aller chercher bien loin. Ou alors il faut être très souple sur la notion de représentation et accepter qu'un flottant représente tout un intervalle de R (ce qu'on fait parfois pour justifier les règles d'arrondi des opérations en flottants).

Par ailleurs, en Python, les variables n'ont pas de type, seules les valeurs en ont. On peut ainsi écrire

Code:

x = 3
x = "toto"


sans que cela ne provoque d'erreur (ce qui ne serait pas possible en C, en Pascal ou en OCaml par exemple où une variable est déclarée, pour les deux premiers cas, ou au moins définie, dans le troisième, avec un type précis qui ne peut évoluer).

En revanche, attribuer ainsi des valeurs de types différents à une même variable n'est en général pas judicieux pour la lisibilité du programme, et je l'interdis à mes élèves sauf justification particulière. Ce qui veut dire que de fait, une variable est astreinte à ne désigner des valeurs que d'un seul type, mais c'est par convention d'écriture des programmes et non en raison du langage Python lui-même.

Mais c'est important en effet de comprendre que les valeurs ont des types et que ces types sont disjoints (un entier n'est pas un flottant), même si Python procède parfois à des conversions implicitement.

Yann Salmon a précisément écrit un article de blog intitulé Informatique en seconde : que savoir sur les flottants ?

N'étant pas concerné par l'enseignement en seconde et n'ayant pas lu les programmes, je ne peux pas vous indiquer s'il est judicieux d'enseigner les subtilités du calcul en virgule flottante aux élèves de seconde. Cela me paraît cependant un peu exagéré, et j'aurais spontanément tendance à suivre le conseil de Yann Salmon qui indique :

le programme de seconde ne demande pas d'enseigner les subtilités des flottants aux élèves. Cependant, au cours de leurs manipulations, les élèves peuvent obtenir des résultats qui semblent aberrants si on assimile les flottants aux réels [...]. Il peut être utile au professeur d'en savoir un peu plus afin de pouvoir en dire suffisamment aux élèves pour que l'informatique et les résultats qu'elle donne n'apparaissent pas comme quelque chose d'ésotérique.

Il me semble qu'il y a beaucoup de choses importantes à faire avec les élèves avant d'aborder la représentation binaire des nombres en virgule flottante. Peut-être convient il donc d'apprécier les propositions des éditions Didier avec un peu de recul et considérer qu'il n'est pas obligatoire d'aller aussi loin qu'ils le proposent avec les élèves de seconde.

Merci e1654d. Disons que le manuel ne dit pas exactement qu'on pourrait représenter les décimaux en binaire. Il explique ce qui se passe si on imaginait une démarche pour les représenter en binaire et on se rend ainsi compte que ça pose problème. Ca ne me parait pas stupide. En revanche, ça me parait bien compliqué pour des Secondes! J'ai vu que tu enseignais en CPGE mais tu peux imaginer à quel point ce concept peut paraître dément pour des Secondes...

Effectivement BR, ton argument tient la route. Merci pour les sources en tout cas!

Effectivement si c'est présenté comme ça c'est judicieux.

En CPGE, le programme suggère de présenter ça au début du premier semestre, avec l'organisation physique d'un ordinateur (mémoire, CPU, etc.). Ça me parait non pertinent dans les classes ou j'enseigne (ça le serait peut-être pour des élèves de PTSI par exemple) ; je fais ça en janvier/février. Donc en seconde…

Ce que j'indique à mes classes en début d'année, c'est qu'il y a des difficultés techniques avec les nombres à virgule, que des choix ont dû être faits et que ça a les conséquences qu'on observe, mais qu'on verra ça plus tard (ma préoccupation étant de ne pas faire apparaitre l'informatique comme un truc ésotérique mais comme quelque chose qui s'explique). En seconde, le plus tard risque d'être beaucoup plus tard, c'est tout.

Je n'enseigne pas les maths mais programme - à l'occasion - en python.

Aller aussi loin sur les flottants me semble aussi contre-productif. Les bizarreries, ils feront avec si tu leur expliques mais l'intérêt d'apprendre à coder c'est de pouvoir bidouiller.
Alors, sans connaître les programmes de seconde, quitte à être en dehors des clous, ne vaut-il pas mieux passer aux  listes, tupples et dictionnaires ( surtout ces derniers pour contrôler les flux et éviter de fastidieuses séries de if... ) ?

Je suis assez partagé sur la bidouille. On peut bidouiller, mais en secret, car c'est sale. Ça ne me parait pas avoir sa place dans un lycée ni surtout dans un enseignement scientifique. On ne bidouille pas en math ni en physique, il n'y a pas de raison de le faire en informatique. Même s'il est vrai que l'expérimentation (ce qui est différent) est plus aisée.

Et justement, l'idée n'est pas d'apprendre « à coder » mais d'apprendre un tout petit peu d'informatique.

Ça me parait inévitable de sortir un tuple ou une liste de temps en temps si on veut écrire des programmes un peu intéressants sans ne faire que de l'arithmétique (position qui se défend aussi, surtout compte tenu des circonstances de cet enseignement). Mais déjà ces structures sont hors programme, et pour de bonnes raisons.

Quant aux dictionnaires, ils ne sont même pas au programme de CPGE (hors l'option informatique de MP), alors…

Gilles, j'aimerais bien mais franchement... pas le temps! (Je ne parle pas en terme de préparation perso mais en terme de temps avec les élèves)

Je suis d'accord avec toi e1654d. Tu m'as convaincu, je passerai donc le temps nécessaire pour parler de l'écriture en binaire d'un entier : ça fera travailler le calcul mental et les puissances, ça leur fera pas de mal. Mais je continue à me dire que cet aménagement est bien trop lourd. Je fais AP classe entière toutes les semaines (heureusement que chez nous on a une grande autonomie là dessus), c'est le seul moyen pour traiter à peu près correctement l'intégralité (et je pèse mes mots sur le "à peu près")

Je rebondis sur ton propos.
Quand, dans une autre vie, j'étais documentaliste d'un centre de documentation d'un CFA de grand lycée de province, venaient des prépas sup pour travailler dans le calme. Un jour l'un d'eux était bien embêté pour écrire en binaire un nombre écrit en décimal, râlant sur les divisions euclidiennes successives à faire. Il m'a fallu lui expliquer qu'il suffisait de faire des soustractions successives de puissances de 2, à l'égyptienne.
D'où ma question : quelle méthode enseignez-vous à vos élèves/étudiants ?

C'est vrai que le passage en base 2 n'est pas connu de tout le monde, même en début de sup, ce qui m'a beaucoup surpris la première fois (il me semblait qu'on faisait ça au collège). Et les bases d'une façon générale ; quand j'avais demandé d'écrire une fonction Python qui renvoie la somme des chiffres (implicitement, en base 10) d'un entier, certains ne voyaient pas du tout comment décomposer l'entier en ses chiffres (bien sûr l'idée n'était pas de faire str(x)).

Je repars de la base 10 : j'écris 342 au tableau et par des divisions successives par 10 (posées comme en primaire, avec quotient et reste) je retrouve l'écriture en base 10 de ce nombre. Puis je fais la même chose en base 2. Ça passe assez bien.

Quand on a plus l'habitude, en effet, on peut procéder (et je le fais une fois ou deux) en se raccrochant aux puissances de deux connues (encore faut-il les connaitre) : 342 c'est 256 + 86, etc.

Mon but ne va pas être d'expertiser l'écriture en base 2 d'un entier (ce n'est pas un attendu du programme et je ne l'évaluerai pas) : je vais me contenter de le faire en activité introductive pour mieux comprendre la notion de flottant. Je vais donc suivre le protocole de l'activité qui me parait très bien : on fait calculer les puissances de deux successives jusqu'à 2^5, puis à l'aide de ça, on demande d'écrire 38 par exemple à l'aide de la somme de puissances de 2 à n'utiliser à chaque fois qu'une seule fois au plus.

Merci.
Les puissances de 2 sont tellement entrées dans la culture commune (via les quantités de mémoire des DD, des SSD, des Clés USB et autres RAM) que même des collégiens préfèrent faire des soustractions successives de celles-ci, en effet.

J'ai pas mal réfléchi aux chaînes de caractère. J'ai du mal à voir jusqu'où il faut aller. L'indice par exemple traite des exercices où on extrait un caractère d'une chaîne (par exemple C[2]) renvoie le troisième élément d'une chaîne de caractères C, le signe + permet la concaténation de deux chaînes. Pensez vous que ce soit utile d'aller jusque là? ou plus loin encore?

Extraire un caractère d'une chaine, trouver sa longueur, concaténer deux chaines, c'est ce qu'on demande aux élèves de CPGE. Donc je pense que ça suffit largement en seconde.

Après, on peut construire des algorithmes dessus : compter le nombre de tels caractères qui apparait dans une chaine, dire si une chaine contient deux caractères identiques à suivre, si c'est un palindrome, si c'est une alternance voyelle-consonne, etc. Sur ce point, le algorithme explicitement au programme en CPGE, c'est la recherche naïve d'un facteur dans une chaine (ie. "vent le" est un facteur de "vivent les cornichons !") : on regarde si le facteur cherché apparait à partir de la position 0, si ça ne marche pas on regarde à partir de la position 1, etc. Rien de bien compliqué.

D'expérience, la manipulation des chaines n'est pas aisée pour certains, notamment ceux qui ne comprennent pas spontanément, ni même après deux explications, la différence entre toto la variable (qui peut désigner une chaine) et "toto" la chaine dont les caractères sont t, o, t, o.


Un bon premier exercice à mon avis est l'écriture d'une fonction qui étant donné une chaine de longueur impaire renvoie le caractère qui se trouve au milieu. On voit tout de suite ce qu'on veut obtenir, il n'y a pas de boucle, mais malgré tout ça nécessite d'avoir bien compris les éléments de base des manipulations de chaines.

e1654d a écrit: Sur ce point, le algorithme explicitement au programme en CPGE, c'est la recherche naïve d'un facteur dans une chaine (ie. "vent le" est un facteur de "vivent les cornichons !") : on regarde si le facteur cherché apparait à partir de la position 0, si ça ne marche pas on regarde à partir de la position 1, etc. Rien de bien compliqué.

Le vocabulaire a t-il changé ?
Autrefois on disait que l'on cherchait une occurrence dans une chaîne...

JPhMM a écrit:Les puissances de 2 sont tellement entrées dans la culture commune (via les quantités de mémoire des DD, des SSD, des Clés USB et autres RAM)

et le jeu 2048

J'ai tendance à parler d'occurrence d'un caractère dans une chaine.
Le vocabulaire facteur me vient des langages formels ; il est également très courant de parler de sous-chaine (substring), mais dans les langages formels, le terme sous-mot désigne une extraction non nécessairement consécutive, comme pour une sous-suite, et je préfère éviter tout risque de confusion pour mes étudiants qui suivront le cours d'option informatique (où on fait un peu de langages formels).

e1654d a écrit:Sur ce point, le algorithme explicitement au programme en CPGE, c'est la recherche naïve d'un facteur dans une chaine (ie. "vent le" est un facteur de "vivent les cornichons !") : on regarde si le facteur cherché apparait à partir de la position 0, si ça ne marche pas on regarde à partir de la position 1, etc. Rien de bien compliqué.

Tortionnaire !

print("vent le" in "vivent les cornichons") ça suffit bien non ?


oui, je sais, je sais, d'ailleurs je suis déjà parti

Mon fils a "écrire une fonction qui retourne une liste" à faire en DM d'info en MPSI.
Je lui ai proposé
def retourne(l): return(l[::-1])

ben2510 a écrit:Mon fils a "écrire une fonction qui retourne une liste" à faire en DM d'info en MPSI.
Je lui ai proposé
def retourne(l): return(l[::-1])

def retourne():
    return []

Retourner une liste ? En trichant un peu :

Code:

def retourne(l):
    return list(reversed(l))


En exploitant les spécificités des listes Python :

Code:

def retourne(l):
    return [l[-k] for k in range(1,1+len(l))]


En faisant n'importe quoi :

Code:

def retourne(liste):
   inverse=[]
   for x in liste:
      inverse.insert(0,x)
   return inverse


AmyR a écrit:

ben2510 a écrit:Mon fils a "écrire une fonction qui retourne une liste" à faire en DM d'info en MPSI.
Je lui ai proposé
def retourne(l): return(l[::-1])

def retourne():
    return []

retourne != renvoie

Le fragment d'énoncé est un peu ambigu : faut-il renvoyer une nouvelle liste qui est la version retournée de la première, ou bien réarranger sur place les éléments de la liste ? Je penche pour la deuxième hypothèse, vu la formulation, mais les intervenants précédents ont plutôt choisi la première.

Vu le style peu pythonesque des questions suivantes, je soupçonne le collègue d'avoir été formé en C, ce qui pousserait vers la deuxième hypothèse.

Il aura une fonction qui retourne une liste retournée :-)