Écrivez la fonction est_OK qui teste si une chaine est OK, mais sans prendre en compte les majuscules :

>>> est_OK("OK")
True
>>> est_OK("oK")
True
>>> est_OK("ok")
True
>>> est_OK("KO")
False
>>> est_OK("")
False
>>> est_OK("okapi")
False

Écrivez la fonction est_Python qui teste si une chaine est Python, mais sans prendre en compte les majuscules :

>>> est_Python("python")
True
>>> est_Python("PyThOn")
True
>>> est_Python("P")
False
>>> est_Python("python-3.4")
False

Programmez, en utilisant un if ...: elif: ... else: ... la fonction est_bissextile du TD2.

Rappel : une année est bissextile si

• elle est divisible par 4 mais pas par 100,
• ou elle est divisible par 400.

Testez (et mettez les valeurs correspondantes dans un commentaire) votre fonction en choisissant des valeurs qui utilisent tous les cas possibles.

Écrivez une fonction nb_jours qui prend deux arguments :

• une année (nombre entier)
• un numéro de mois (nombre entier)

et qui renvoie le nombre de jours dans le mois correspondant.

Par exemple

  >>> nb_jours(2015,9)
  30
  >>> nb_jours(2000,2)
  28

Écrivez une fonction qui renvoie le nombre de points d'une carte à la belote.

Votre fonction devra prendre 3 arguments

• la famille d'une carte: c'est une chaine de caractères qui vaut "pique","coeur","trefle" ou "carreau" ;
• la numéro d'une carte: c'est un nombre entier, avec 1 pour l'as, 11 pour le valet, 12 pour la dame et 13 pour le roi ;
• la famille d'atout : c'est une chaine de caractère qui contient la famille de l'atout pour la partie.

Rappel : le nombre de points rapportés par les cartes à la belote sont

Fournissez (en commentaire) l'ensemble des tests effectués.

Tapez les lignes suivantes dans l'interpréteur :

>>> for i in range(1, 10):
        print("la variable de boucle 'i' vaut", i)

???

Remarque : comme l'instruction de boucle tient sur plusieurs lignes, l'interpréteur attend de voir une ligne blanche avant d'évaluer le bloc de code.

Recommencez en changeant le i du print par:

• print(..., 2i)
• print(..., 3i)
• print(..., i*i)
• print(..., 10-i)

et essayez de deviner à chaque fois ce que l'interpréteur affichera.

Écrivez, en utilisant une boucle for, une fonction compte_triangle avec un paramètre entier n qui compte le nombre d'étoiles dans un triangle de n lignes comme celui ci :

*
**
***
****
*****

Ce triangle contient 5 lignes et 15 étoiles au total. On aura donc

>>> compte_triangle(5)
15

Remarque : comme la ligne i contient exactement i étoiles, il s'agit en fait de la fonction qui calcule la somme des n premiers nombres entiers. Ces nombres sont appelés nombres triangulaires !

Ajoutez une ligne dans la fonction compte_triangle de la question précédente pour afficher les informations suivantes :

>>> compte_triangle(7)
ligne 1: il y a déjà eu 1 étoiles
ligne 2: il y a déjà eu 3 étoiles
ligne 3: il y a déjà eu 6 étoiles
ligne 4: il y a déjà eu 10 étoiles
ligne 5: il y a déjà eu 15 étoiles
ligne 6: il y a déjà eu 21 étoiles
ligne 7: il y a déjà eu 28 étoiles
28

Dans le calcul précédent, il faut bien distinguer les lignes contenant les informations affichées par le print et le résultat de la fonction, affiché par l'interpréteur (ici, le nombre 28). Les informations seront toujours affichées, même lorsqu'on utilise une variable pour stocker le résultat de la fonction.

Évaluez les expressions suivantes en essayant de deviner à l'avance ce qui se passera.

>>> x = compte_triangle(5)
???
>>> y = compte_triangle(6)
???
>>> x
???
>>> y
???
>>> compte_triangle(3) + compte_triangle(4)
???

Programmez, une fonction somme7 à un argument entier n qui calcule la somme des n premiers multiples de 7.

Attention, vous ne devez pas utiliser le pas (troisième argument du range.)

Par exemple :

>>> somme7(4)
70
>>> somme7(5)
105

car 7 + 14 + 21 + 28 = 70 et 7 + 14 + 21 + 28 + 35 = 105.

Écrivez une fonction compte_espaces avec un argument s de type chaine de caractères qui renvoie le nombre de caractères « espace » contenus dans la chaine s. Par exemple :

>>> compte_espaces("Salut, je m'appelle Bob !")
4

Ajouter une ligne pour afficher le nombre d'espaces à chaque fois que la fonction en trouve un :

>>> compte_espaces("Salut, je m'appelle Bob !")
le caractère 6 est un espace : il y en a 1
le caractère 9 est un espace : il y en a 2
le caractère 19 est un espace : il y en a 3
le caractère 23 est un espace : il y en a 4
4

Lorsque cela fonctionne, commentez la ligne correspondante pour supprimer l'affichage des informations.

Écrivez un fonction compte_car_doubles à un argument s de type chaine de caractères qui compte le nombre de symboles doublés dans s. Par exemple,

>>> compte_car_doubles("ce mouton carnassier a une grosse tete")
???

car il y a deux lettres doublées : ce mouton carnassier a une grosse tete.

Essayez de deviner le résultat de votre fonction sur la chaine "Chut... Le bébé rhinocéros fait la sieste." et vérifiez le résultat.