<jupyter_start><jupyter_text>1A.1 - Variables, boucles, testsRépétitions de code, exécuter une partie plutôt qu'une autre.<jupyter_code>from jyquickhelper import add_notebook_menu
add_notebook_menu()<jupyter_output><empty_output><jupyter_text>Partie 1 : variables, int, float, str, list Un algorithme manipule des données. Ces données ne sont pas connues au moment où on écrit l'algorithme. Les variables servent à nommer ces données afin de pouvoir écrire cet algorithme. On procède la plupart du temps dans l'ordre suivant :* On écrit l'algorithme.* On affecte des valeurs aux variables.* On exécute l'algorithme.Quelques exemples à essayer autour des variables :<jupyter_code>i = 3                    # entier = type numérique (type int)
r = 3.3                  # réel   = type numérique (type float)
s = "exemple"            # chaîne de caractères = type str (exemple n'est pas une variable)
s = 'exemple'            # " et ' peuvent être utilisées pour définir une chaîne de caractères
sl = """ exemple sur
plusieurs lignes"""      # on peut définir une chaîne sur plusieurs lignes avec """ ou '''             
n = None                 # None signifie que la variable existe mais qu'elle ne contient rien
                         # elle est souvent utilisée pour signifier qu'il n'y a pas de résultat
                         # car... une erreur s'est produite, il n'y a pas de résultat
                         # (racine carrée de -1 par exemple)
            
i,r,s,n, sl              # avec les notebooks, le dernier print n'est pas nécessaire, il suffit d'écrire
                         # i,r,s,n
v = "anything"       # affectation
print ( v )          # affichage
v1, v2 = 5, 6        # double affectation
v1,v2<jupyter_output>anything<jupyter_text>Par défaut, le notebook affiche le résultat présent sur la dernière ligne de la cellule. S'il on souhaite en afficher plusieurs, il faut utiliser la fonction [print](https://docs.python.org/3/library/functions.html?highlight=printprint).<jupyter_code>x = 3
print(x)
y = 5 * x
y
x,y = 4,5 
s = "addition"
"{3} de {0} et {1} donne : {0} + {1} = {2}".format (x,y,x+y,s)<jupyter_output><empty_output><jupyter_text>La dernière écriture permet d'assembler différentes valeurs en une seule chaînes de caractères. C'est très pratique lorsqu'on veut répéter le même assemblage un grand nombre de fois. Ce mécanisme ressemble à celui des lettres type : c'est un texte à trou qu'on remplit avec des valeurs différentes à chaque fois.<jupyter_code>for prenom in [ "xavier", "sloane"] :
    print ("Monsieur {0}, vous avez gagné...".format(prenom))<jupyter_output>Monsieur xavier, vous avez gagné...
<NAME>, vous avez gagné...<jupyter_text>**Type d'une variable :**<jupyter_code>print ( type ( v ) )           # affiche le type d'une variable
print ( isinstance (v, str) )  # pour déterminer si v est de type str<jupyter_output><class 'str'>
True<jupyter_text>**Les tableaux ou listes (list) :**<jupyter_code>c  = (4,5)                # couple de valeurs (ou tuple)
l  = [ 4, 5, 6.5]         # listes de valeurs ou tableaux
x  = l [0]                # obtention du premier élément de la liste l
y  = c [1]                # obtention du second élément
le = [ ]                  # un tableau vide
c,l,x,y,le
l  = [ 4, 5 ]
l += [ 6 ]      # ajouter un élément
l.append ( 7 )  # ajouter un élément
l.insert (1, 8) # insérer un élément en seconde position
print(l)
del l [0]       # supprimer un élément
del l [0:2]     # supprimer les deux premiers éléments
l<jupyter_output>[4, 8, 5, 6, 7]<jupyter_text>**Longueur d'une liste et autres :**<jupyter_code>l = [ 4, 5, 6 ]
print ( len(l) )    # affiche la longueur du tableau
print ( max(l) )    # affiche le plus grand élément
s = l * 3           # création de la liste [ 4, 5, 6, 4, 5, 6, 4, 5, 6 ]
t = s [ 4:7 ]       # extraction de la sous-liste de la position 4 à 7 exclu
s [4:7] = [ 4 ]     # remplacement de cette liste par [ 4 ]
s<jupyter_output>3
6<jupyter_text>Type **mutable** et **immutable** (voir aussi [Qu'est-ce qu'un type immuable ou immutable ?](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/all_FAQ.htmlqu-est-ce-qu-un-type-immuable-ou-immutable)) : une liste est un type **mutable**. Cela veut dire que par défaut, l'instruction ``list1=list2`` ne recopie pas la liste, elle lui donne un autre nom qui peut être utilisé en même temps que le premier.<jupyter_code>l1 = [ 0, 1 ,2 ]
l2 = l1
l2[0] = -1
l1,l2<jupyter_output><empty_output><jupyter_text>Les deux listes sont en apparence modifiées. En fait, il n'y en a qu'une. Pour créer une copie, il faut explicitement demander une copie.<jupyter_code>l1 = [ 0, 1 ,2 ]
l2 = list(l1)
l2[0] = -1
l1,l2<jupyter_output><empty_output><jupyter_text>C'est un point très important du langage qu'il ne faut pas oublier. On retrouve cette convention dans la plupart des [langages interprétés](http://en.wikipedia.org/wiki/Interpreted_language) car faire une copie alourdit le temps d'exécution.  Partie 2 : TestsLes tests permettent de faire un choix : selon la valeur d'une condition, on fait soit une séquence d'instructions soit une autre.<jupyter_code>v = 2
if v == 2 :
    print ("v est égal à 2")
else :
    print ("v n'est pas égal à 2")<jupyter_output>v est égal à 2<jupyter_text>La clause ``else`` n'est obligatoire :<jupyter_code>v = 2
if v == 2 :
    print ("v est égal à 2")<jupyter_output>v est égal à 2<jupyter_text>Plusieurs tests enchaînés :<jupyter_code>v = 2
if v == 2 :
    print ("v est égal à 2")
elif v > 2 :
    print ("v est supérieur à 2")
else :
    print ("v est inférieur à 2")<jupyter_output>v est égal à 2<jupyter_text>Partie 3 : boucles Les boucles permettent de répéter un nombre fini ou infini de fois la même séquence d'instructions.Quelques exemples à essayer autour des boucles :<jupyter_code>for i in range (0, 10) :   # on répète 10 fois
    print ("dedans",i)     # l'affichage de i
    # ici, on est dans la boucle
# ici, on n'est plus dans la boucle
"dehors",i                 # on ne passe par 10<jupyter_output>dedans 0
dedans 1
dedans 2
dedans 3
dedans 4
dedans 5
dedans 6
dedans 7
dedans 8
dedans 9<jupyter_text>**Boucle while :**<jupyter_code>i = 0
while i < 10 :
    print (i)
    i += 1<jupyter_output>0
1
2
3
4
5
6
7
8
9<jupyter_text>**Interrompre une boucle :**<jupyter_code>for i in range (0, 10) : 
    if i == 2 :
        continue           # on passe directement au suivant
    print (i)            
    if i > 5 :
        break              # interruption définitive<jupyter_output>0
1
3
4
5
6<jupyter_text>**Parcours d'une liste :** observer les différences entre les trois écritures<jupyter_code>l = [ 5, 3, 5, 7 ]
for i in range (0, len(l)) :
    print ("élément ",i, "=", l [ i ] ) 
l = [ 5, 3, 5, 7 ]
for v in l :
    print ("élément ", v ) 
l = [ 5, 3, 5, 7 ]
for i,v in enumerate(l) :
    print ("élément ",i, "=", v )<jupyter_output>élément  0 = 5
élément  1 = 3
élément  2 = 5
élément  3 = 7<jupyter_text>**Que fait le programme suivant ?**<jupyter_code>l = [ 4, 3, 0, 2, 1 ]
i = 0
while l[i] != 0 :
    i = l[i]
    print (i)            # que vaut l[i] à la fin ?<jupyter_output>4
1
3
2<jupyter_text>On peut jouer avec des cartes pour faire dénouer le côté sybillin de ce programme : [La programmation avec les cartes](http://lesenfantscodaient.fr/blog/2015-09-05_jeu_pour_les_grands.html).  Partie 4 : les listes compactes, les ensemblesPlutôt que d'écrire :<jupyter_code>l = [ ]
for i in range (10) :
    l.append( i*2+1)
l<jupyter_output><empty_output><jupyter_text>On peut écrire :<jupyter_code>l = [ i*2+1 for i in range(10) ]
l<jupyter_output><empty_output><jupyter_text>Quelques examples à essayer :<jupyter_code>l = [ i*2 for i in range(0,10) ]
l  # qu'affiche l ?
l = [ i*2 for i in range(0,10) if i%2==0 ]
l  # qu'affiche l ?<jupyter_output><empty_output><jupyter_text>Les ensembles ou **set** sont des listes pour lesqueelles les éléments sont uniques. Si deux nombres nombres *int* et *float* sont égaux, seul le premier sera conservé.<jupyter_code>l = [ "a","b","c", "a", 9,4,5,6,7,4,5,9.0]
s = set(l)
s<jupyter_output><empty_output><jupyter_text>Partie 5 : recherche non dichotomique (exercice)On veut écrire quelques instructions pour trouver la position du nombre ``x = 7`` dans la liste ``l``. Il faut compléter le programme suivant en utilisant une boucle et un test.<jupyter_code>l = [ 3, 6, 2 , 7, 9 ]
x = 7

# ......

print ( position )<jupyter_output><empty_output><jupyter_text>Partie 6 : Recherche dichotomique La [recherche dichotomique](http://fr.wikipedia.org/wiki/Dichotomie) consiste à chercher un élément ``e`` dans un tableau trié ``l``. On cherche sa position :* On commence par comparer ``e`` à l'élément placé au milieu du tableau d'indice ``m``, s'ils sont égaux, on a trouvé,* s'il est inférieur, on sait qu'il se trouve entre les indices 0 et ``m-1``,* s'il est supérieur, on sait qu'il se trouve entre les indices ``m+1`` et la fin du tableau.Avec une comparaison, on a déjà éliminé une moitié de tableau dans laquelle on sait que ``p`` ne se trouve pas. On applique le même raisonnement à l'autre moitié pour réduire la partie du tableau dans laquelle on doit chercher.<jupyter_code>l = sorted( [ 4, 7, -1,3, 9, 5, -5 ] )

# recherche dichotomique
# la position retournée est correspond à celle de l'élément dans le tableau trié<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10908505845757803, 'fraction_numerical': 0.02585004826772498, 'mean_word_length': 3.5, 'pattern_counts': {'":': 0, '<': 83, '<?xml version=': 0, '>': 84, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '271276', 'license': 'MIT', 'n_tokens_mistral': 3609, 'n_tokens_neox': 3489, 'n_words': 1193, 'path': '_doc/notebooks/td1a/td1a_cenonce_session2.ipynb', 'repo_name': 'Jerome-maker/ensae_teaching_cs', 'size': '9332'}