Donnez des exemples d'expressions qui ne sont pas affectables.

Parmi les morceaux de Python suivant, lesquels sont des expressions, des expressions affectables ou des instructions ?

Ecrire la fonction position qui prend en paramètres :

• lettre, une chaine de caractères réduite à un seul caractère
• mot, une chaine de caractères représentant un mot et renvoie
• la position de la lettre dans mot de lettre si lettre apparaît dans mot,
• -1 sinon.

Attention : il s’agit bien de position et pas d’indice.

Exemples :

>>> position('2', '2abcàâç')
    1
>>> position('c', '2abcàâç')
    4
>>> position('a', '0 ,.:;!?')
    -1

On représente les touches du téléphone par un tableau de chaines de caractères nommé Ttel qui comporte 10 cases (autant que de touches). Dans la case d'indice i, se trouve la suite de caractères qu'il est possible d'obtenir en appuyant sur la touche i. Ainsi par exemple :

>>> Ttel[0]
      "0 ,.:;!?"
>>> Ttel[2]
      "2abcàâç"
>>> Tt"l[6]
      "6mnoô"
>>> Ttel[8]
      "8tuvùû"

En utilisant la fonction position si besoin, écrire la fonction no_touche qui prend en paramètres :

• lettre, un caractère
• tab, un tableau de chaines de caractères représentant les touches d'un téléphone (même format que Ttel)

et renvoie le numéro de la touche sur laquelle il faut appuyer pour pouvoir sélectionner le caractère lettre. Il s'agit de l'indice de la case de tab dans laquelle est stockée la chaine qui contient lettre.

Exemples :

>>> no_touche('c', Ttel)
    2
>>> no_touche('o', Ttel)
    6
>>> no_touche('u', Ttel)
    8
>>> no_touche('!', Ttel)
    0

Il est à noter que la fonction no_touche peut s'utiliser avec n'importe quel tableau de chaines de caractères. Ainsi par exemple :

    >>> no_touche('c', ['abc', 'def', 'ghi', 'jkl', 'mnopq', 'rstu', 'vwxyz'])
        0
    >>> no_touche('m', ['abc', 'def', 'ghi', 'jkl', 'mnopq', 'rstu', 'vwxyz'])
        4

En utilisant les fonctions position et no_touche, écrire la fonction sms qui prend en paramètres :

• message, une chaine de caractères, un message à envoyer par sms,
• tab, un tableau de chaines de caractères représentant les touches du téléphone,

et renvoie un tableau de nombres dans lequel il est indiqué combien de fois il faut appuyer sur quelles touches pour obtenir le message. Le résultat est ainsi une suite de nombres de la forme :

    [nb de fois, n° de touche, nb de fois, n° de touche, ...]

Ce tableau sera ensuite utilisé comme une consigne « envoyée » au téléphone pour composer le message automatiquement.

Par exemple :

>>> sms('coucou !', Ttel)
    [4, 2, 4, 6, 3, 8, 4, 2, 4, 6, 3, 8, 2, 0, 6, 0]

Pour obtenir coucou !, il faut en effet appuyer :

• 4 fois sur la touche 2 (pour obtenir le c),
• 4 fois sur la touche 6 (pour obtenir le o),
• 3 fois sur la touche 8 (pour obtenir le u),
• 4 fois sur la touche 2 (pour obtenir le c),
• 4 fois sur la touche 6 (pour obtenir le o),
• 3 fois sur la touche 8 (pour obtenir le u),
• 2 fois sur la touche 0 (pour obtenir l'espace),
• 7 fois sur la touche 0 (pour obtenir le !),

Les nombres de fois (soulignés) :

• [ 4, 2, 4, 6, 3, 8, 4, 2, 4, 6, 3, 8, 2, 0, 7, 0 ]

Les numéros de touche (soulignés) :

• [ 4, 2, 4, 6, 3, 8, 4, 2, 4, 6, 3, 8, 2, 0, 7, 0 ]

Écrivez, en utilisant une boucle for, une fonction qui calcule la somme de tous les nombres contenus dans un tableau.

Ré-écrivez cette fonction en utilisant cette fois ci une boucle while.

Quelle version préferrez vous?

Écrivez, en utilisant une boucle for, une fonction qui calcule la somme de tous les nombres contenus dans les cases d'indice impair d'un tableau.

Ré-écrivez cette fonction en utilisant cette fois ci une boucle while.

Quelle version préferrez vous?

Écrivez, en utilisant une boucle for, une fonction qui calcule la somme de tous les nombres pairs dans un tableau.

Ré-écrivez cette fonction en utilisant cette fois ci une boucle while.

Quelle version préferrez vous?

On dispose d'un tableau precipitations qui donne le montant annuel des précipitations pour chaque année depuis 1900. Par exemple, le montant des précipitations de l'année 1925 est contenu dans la case 25 du tableau.

Écrivez une fonction qui calcule le maximum des précicipations annuelles pour toutes les années non bissextiles. (Rappel : les années bissextiles sont les années divisible par 4 ou 400, mais pas par 100.)

Même question, mais pour les années bissextiles.

Écrivez une fonction à deux arguments c et s qui teste si une lettre (c) apparait dans une chaine (s):

• avec une boucle for qui parcourt tout le tableau,
• avec une boucle for qui s'arrète dès que la lettre cherchée est trouvée,
• avec une boucle while qui s'arrète dès que la lettre cherchée est trouvée.

Quelle version préferrez vous?

Écrivez une fonction qui teste si un tableau est monotone : si le tableau est trié (croissant ou décroissant), le résultat est True, sinon, le résultat est False.

Une balle en caoutchouc rebondit et perd, à chaque rebond, de la hauteur. Par exemple, un balle avec un coefficient de rebond de 85% perdra 15% de hauteur à chaque rebond.

Écrivez une fonction nb_rebonds(coeff, h1, h2) qui calcule le nombre de rebond nécessaires pour que une balle dont le coefficient est coeff rebondisse en dessous de h2 cm lorsqu'elle est lachée de h1 cm de hauteur.

Écrivez une fonction duree(montant_initial, taux, montant_final) qui calcule le nombre d'années nécessaires pour que le montant initial rapporte au moins le montant final pour le taux d'intérêt donné.

On peut simuler un lancer de dés avec la fonction randint(1,6) qui tire un nombre entier entre 1 et 6 au hasard. (Il faut charger la fonction avec une ligne from random import randint au début de votre fichier...)

Écrivez une fonction nb_lancers(score) qui compte le nombre de lancers de dés qu'il faut ajouter pour obtenir au moins le score.

Modifiez la fonction précédente pour que le dernier lancer « tombe juste ». Autrement dit, si le score actuel est 23 et qu'il faut obtenir 25, un 4 comptera comme un lancer mais ne participera pas au score (on ne peut pas dépasser) ; par contre, un 1 comptera normalement car il ne fait pas dépasser.

Rappel : la fonction input attend que l'utilisateur tape quelque chose au clavier et renvoie la chaine correspondante.

Écrivez une fonction couleur qui affiche le menu suivant:

      rouge : R
      vert : V
      bleu : B

et qui attend que l'utilisateur rentre une lettre. Tant que l'utilisateur ne rentre ni R, ni V, ni B, votre fonction devra redemander :

    Mauvais choix
      rouge : R
      vert : V
      bleu : B

Votre fonction renverra le nom complet de la couleur finalement choisie.

La fonction suivante permet de calculer l'indice d'un élément dans un tableau (ou -1 si l'élément n'apparait pas dans la tableau).

def indice(T, e):
    """recherche l'indice de la valeur e dans le tableau T
Si la valeur e n'apparait pas dans T, renvoie -1"""
    r = -1
    i = 0
    while 0 <= i < len(T) and r == -1:
        if T[i] == e:
            r = i
        i = i+1
    return r

Lorsque la valeur e apparait en position n, la fonction inspecte exactement n cases du tableau. Lorsque la valeur e n'apparait pas, elle inspecte toutes les cases du tableau.

Lorsque le tableau T est trié par ordre croissant, il est possible d'inspecter moins de cases: on regarde la case au milieu de T et

• si cette case est égale à e, on a trouvé la valeur et son indice,
• si cette case est plus grande que e, on continue la recherche dans la première moitié de T,
• inversement, si cette case est plus petite que e, on continue la recherche dans la seconde moitié de T.

Bien entendu, on continue de la même manière en cherchant dans une moitié de moitié, puis une moitié de moitié de moitié, etc.

Indice: pour chercher la valeur e entre les indices i et j du tableau, il faut regarder la case c = (i+j)//2, et continuer sur la bonne moitié:

• soit entre i et c,
• soit entre c et j.

Lorsque qu'il n'y a plus de cases dans la partie concernée du tableau, c'est que la valeur n'était pas présente: on renvoie alors -1.

Il faudra préciser le sens de entre dans l'explication précédente pour spécifier si les bornes sont strictes ou larges. Il faudra ensuite modifier les bornes pour garantir qu'on ne regarde pas plusieurs fois les cases : en particulier, il ne faut pas que la case c reste dans le tableau.

Écrivez une fonction qui calcule le nombre maximal apparaissant dans une case d'indice impair dans un tableau. Par exemple :

    >>> max_impair([0,1,2,3,4,5,10,21,222,111])
    111

Écrivez une fonction à deux arguments max_paquet(t, n) qui calcule :

• le maximum des valeurs aux indices 0,1,…, n-1,
• le maximum des valeurs aux indices n, n+1, …, 2n-1,
• le maximum des valeurse aux indices 2n, 2n+1, …, 3n-1,
• ...

On aura par exemple :

    >>> max_paquet([1,2,3,2, 5,4,3,0, 10,11,10,9,  3,13,23], 4)
    [3, 5, 11, 23]

Écrivez une fonction qui calcule la somme des élements d'un tableau en utilisant les deux types de boucles for :

• for i in range(0, len(t)):
• for e in t: ...

Faites la même chose pour calculer le maximum d'un tableau, puis pour calculer le numéro de la case contenant le maximum.

On considère le tableau à 2 dimensions suivant :

    >>> T = [ [1, 2,],
              [0, 2, -1,],
              [1, 0, 3,  2]]

Quels sont les résultats des expressions suivantes ?

    T[1][1]           T[1][2]     T[2]
    T[T[2][1]][1]     T[3][3]     T[2][T[0][0]]

Une matrice est simplement un tableau à deux dimensions, où chaque tableau interne fait la même taille. Par exemple, le tableau T de l'exercice précédent n'est pas une matrice, mais le tableau suivant en est une :

    >>> M = [ [0, 1, 1, 0],
              [0, 0, 1, 1],
              [1, 2, 3, 4],
              [0, 0, 0, 0],
              [1, 0, 1, 1] ]

Écrivez une fonction qui renvoie le nombre de lignes d'une telle matrice.

Écrivez une fonction qui renvoie le nombre de colonnes d'une telle matrice.

Écrivez une fonction ligne qui prend une matrice et un nombre en argument, et qui renvoie :

• la ligne correspondante dans la matrice,
• ou bien le tableau vide si la ligne n'existe pas dans la matrice.

Écrivez une fonction colonne qui prend une matrice et un nombre en argument, et qui renvoie :

• la colonne correspondante dans la matrice,
• ou bien le tableau vide si la ligne n'existe pas dans la matrice.

Écrivez une fonction diagonale qui prend une matrice et qui renvoie la diagonale de la matrice. Par exemple, pour la matrice donnée plus haut, on obtiendra :

    >>> diagonale(M)
    [0, 0, 3, 0]

Écrivez une fonction anti_diagonale qui prend une matrice et qui renvoie l'anti diagonale de la matrice (celle qui part du coin en haut à droite). Par exemple, pour la matrice donnée plus haut, on obtiendra :

    >>> anti_diagonale(M)
    [0, 1, 2, 0]

Écrivez une fonction est_diagonale qui teste si une matrice est diagonale, càd que la matrice est carrée et que toutes ses valeurs sont 0, sauf éventuellement sur la diagonale.

Écrivez une fonction est_triangulaire qui teste si une matrice est triangulaire, càd que la matrice est carrée et que toutes ses valeurs sous la diagonale sont nulles.

Écrivez une fonction est_triee qui vérifie si toutes les lignes d'un tableau à 2 dimensions sont triées. Votre fonction devra utiliser des boucles while pour s'arrêter le plus tot possible.

Écrivez une fonction contient_zero qui vérifie si toutes les lignes d'un tableau à 2 dimensions contiennent au moins une case à 0. Votre fonction devra utiliser des boucles while pour s'arrêter le plus tot possible.

Écrivez une fonction est_matrice qui teste si un tableau est une matrice :

• le tableau contient au moins une ligne,
• et toutes les lignes ont le même nombre de cases.

Écrivez une fonction add_matrice qui ajoute deux matrices de même taille.

Écrivez une fonction mult_matrices qui multiplie deux matrices de taille compatibles.

Rappel : les deux matrices doivent avoir les tailles n,m et m,l, et le résultat aura la taille n,l.

On considère un dictionnaire où les cases ont des valeurs numériques, comme

>>> D = {"une case": 17,
         "une deuxième case": -3,
         "une autre case": 0,
         "ceci n'est pas une case": 66}

1. Écrivez une fonction qui calcule la somme de toutes les cases.
2. Écrivez une fonction qui calcule le maximum de toutes les cases.
3. Écrivez une fonction qui renvoie une clé contenant une case de valeur minimale.
4. Écrivez une fonction qui renvoie True ou False suivant que le nombre x apparait ou non dans un dictionnaire.

On considère une liste de dictionnaire, où chacun des dictionnaires contient 4 cases :

• une case "nom" et une case "prénom",
• une case "année de naissance",
• une case "no_etudiant"

1. Écrivez une fonction qui calcule la moyenne des ages d'une telle liste.
2. Écrivez une fonction qui renvoie le n° d'étudiant d'un étudiant d'age minimal.

Écrivez une fonction qui permet de faire la réunion de deux dictionnaires. Si D1 et D2 sont deux dictionnaires, union(D1, D2) sera un dictionnaire qui contient les cases de D1 et les cases de D2.

Lorsqu'une clé apparait à la fois dans D1 et dans D2, la valeur de la case correspondante dans union(D1, D2) sera la valeur de la case de D1.

Écrivez une fonction qui permet de faire l'intersection de deux dictionnaires numériques. Si D1 et D2 sont deux dictionnaires, inter(D1, D2) sera un dictionnaire qui contient les clés qui sont à la fois dans D1 et dans D2.

La valeur d'une telle case sera le produit des deux cases correspondantes dans D et D2.

Écrivez une fonction est_palindrome qui vérifie si une chaine est un palindrome //sans prendre la ponctuation, les majuscules ou les espaces en compte//. Par exemple, votre fonction devra répondre True sur les chaines "Was it a car or a cat I saw?", "Le sel..." ou ``"Isä, älä myy myymälääsi."``

Écrivez une procédure multiplications(n) qui affiche la table de multiplication jusqu'à n*n. L'affichage devra ressembler à

>>> multiplication(10)
1    2    3    4    5    6    7    8    9
2    4    6    8   10   12   14   16   18
3    6    9   12   15   18   21   24   27
4    8   12   16   20   24   28   32   36
5   10   15   20   25   30   35   40   45
6   12   18   24   30   36   42   48   54
7   14   21   28   35   42   49   56   63
8   16   24   32   40   48   56   64   72
9   18   27   36   45   54   63   72   81

(Notez l'alignement des colonnes...)

Écrivez une procédure multiplications(n) qui affiche la table de multiplication jusqu'à n*n. L'affichage devra ressembler à

>>> multiplication(12)
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   1 |   2 |   3 |   4 |   5 |   6 |   7 |   8 |   9 |  10 |  11 |  12 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   2 |   4 |   6 |   8 |  10 |  12 |  14 |  16 |  18 |  20 |  22 |  24 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   3 |   6 |   9 |  12 |  15 |  18 |  21 |  24 |  27 |  30 |  33 |  36 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   4 |   8 |  12 |  16 |  20 |  24 |  28 |  32 |  36 |  40 |  44 |  48 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   5 |  10 |  15 |  20 |  25 |  30 |  35 |  40 |  45 |  50 |  55 |  60 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   6 |  12 |  18 |  24 |  30 |  36 |  42 |  48 |  54 |  60 |  66 |  72 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   7 |  14 |  21 |  28 |  35 |  42 |  49 |  56 |  63 |  70 |  77 |  84 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   8 |  16 |  24 |  32 |  40 |  48 |  56 |  64 |  72 |  80 |  88 |  96 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|   9 |  18 |  27 |  36 |  45 |  54 |  63 |  72 |  81 |  90 |  99 | 108 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|  10 |  20 |  30 |  40 |  50 |  60 |  70 |  80 |  90 | 100 | 110 | 120 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|  11 |  22 |  33 |  44 |  55 |  66 |  77 |  88 |  99 | 110 | 121 | 132 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|  12 |  24 |  36 |  48 |  60 |  72 |  84 |  96 | 108 | 120 | 132 | 144 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

(Notez l'alignement des colonnes...)

Écrivez une procédure puissances(n) qui affiche la table des puissances jusqu'à n**n. L'affichage devra ressembler à

>>> puissances(7)
1   1    1     1      1       1       1
2   4    8    16     32      64     128
3   9   27    81    243     729    2187
4  16   64   256   1024    4096   16384
5  25  125   625   3125   15625   78125
6  36  216  1296   7776   46656  279936
7  49  343  2401  16807  117649  823543

(Notez l'alignement des colonnes...)

Écrivez une procédure puissances(n) qui affiche la table des puissances jusqu'à n**n. L'affichage devra ressembler à

>>> puissances(6)
+---+----+-----+------+------+-------+
| 1 |  1 |   1 |    1 |    1 |     1 |
+---+----+-----+------+------+-------+
| 2 |  4 |   8 |   16 |   32 |    64 |
+---+----+-----+------+------+-------+
| 3 |  9 |  27 |   81 |  243 |   729 |
+---+----+-----+------+------+-------+
| 4 | 16 |  64 |  256 | 1024 |  4096 |
+---+----+-----+------+------+-------+
| 5 | 25 | 125 |  625 | 3125 | 15625 |
+---+----+-----+------+------+-------+
| 6 | 36 | 216 | 1296 | 7776 | 46656 |
+---+----+-----+------+------+-------+

(Notez l'alignement des colonnes...)

Écrivez une procédure qui affiche la ligne la plus longue d'un fichier dont le nom est passé en argument.

Écrivez une procédure qui ajoute les numéro de ligne dans un fichier en créant un nouveau fichier avec l'extension ".no".

Si le fichier test.txt contient

        Lorem ipsum dolor sit amet, consectetur
        adipisicing elit, sed do eiusmod tempor
        incididunt ut labore et dolore magna aliqua. Ut
        enim ad minim veniam, quis nostrud exercitation
        ullamco laboris nisi ut aliquip ex ea commodo
        consequat.

alors un appel à no_lignes("test.txt") créera un nouveau fichier test.txt.no dont le contenu sera

        001 - Lorem ipsum dolor sit amet, consectetur
        002 - adipisicing elit, sed do eiusmod tempor
        003 - incididunt ut labore et dolore magna aliqua. Ut
        004 - enim ad minim veniam, quis nostrud exercitation
        005 - ullamco laboris nisi ut aliquip ex ea commodo
        006 - consequat.

Écrivez une fonction qui prend un nom de fichier et un caractère en argument et qui compte le nombre d'occurrence de ce caractère à l'intérieur du fichier.

Écrivez une fonction qui prend un nom de fichier et qui renvoie un dictionnaire où les clés sont les caractères apparaissant dans le fichier et les valeurs sont le nombre d'occurrences de ces caractères dans le fichier.

Par exemple, sur le fichier test.txt précédent, le résultat sera:

    {
      'l': 10, ',': 3, 'r': 9, 'u': 13, 'n': 12, ' ': 30,
      'd': 11, 'g': 2, 'x': 2, 'p': 4, 'q': 4, '\n': 6,
      't': 15, 'i': 24, 'v': 1, 'o': 18, 'c': 8, 'm': 13,
      'e': 18, 's': 11, 'a': 15, '.': 2, 'b': 2
    }

La case 'l' contient 10 car le fichier contient effectivement 10 occurrences du caractère l, en minuscule ou en majuscule.

On dispose d'un fichier contenant des mots par ordre alphabétique avec leur définition. Chaque mot défini est seul sur une ligne et les lignes suivantes sont la définition correspondante. La fin de la définition est notée par un symbole % seul sur une ligne. Par exemple :

    ABAQUE
    1- Terme d'architecture. Tailloir, partie supérieure du chapiteau
    des colonnes, sur laquelle porte l'architrave.
    2- Terme d'antiquité. Tableau couvert de poussière, sur lequel on
    traçait des nombres et on enseignait le calcul ; et aussi sorte de
    carré long, évidé, qui était muni de boules passées dans des fils
    tendus et qui servait à compter.
    %
    ABBAYE
    1- Monastère d'hommes ou de filles.
    2- Le bénéfice attaché au titre d'abbé.
    3- Les bâtiments du monastère
    %
    ABEILLE
    Insecte qui produit le miel et la cire, et qui appartient au genre
    des insectes hyménoptères.
    %
    ...

Écrivez une procédure affiche_definition(nom_fichier, mot) qui affiche la définition d'un mot donné en argument en la cherchant dans le fichier.