Sommaire : Seconde_ipynb

06 - GPS
08 - Image
09 - Python
10 - Nos scripts
14 - Base Python
15 - Base Python Correction
16 - if
17 - if Correction
18 - for
19 - for Correction
20 - while
21 - while Correction
22 - Chaines
23 - Chaines Correction
24 - Etude de Fonction

06 - GPS

Localisation, cartographie et mobilité


Contenus Capacités attendues
GPS, Galileo Décrire le principe de fonctionnement de la géolocalisation.
Cartes numériques Identifier les différentes couches d’information de GeoPortail pour extraire différents types de données.
Contribuer à OpenStreetMap de façon collaborative.
Protocole NMEA 0183 Décoder une trame NMEA pour trouver des coordonnées géographiques.
Calculs d’itinéraires Utiliser un logiciel pour calculer un itinéraire.
Représenter un calcul d’itinéraire comme un problème sur un graphe.
Confidentialité Régler les paramètres de confidentialité d’un téléphone pour partager ou non sa position.

La cartographie est essentielle pour beaucoup d’activités : agriculture, urbanisme, transports, loisirs, etc. Elle a été révolutionnée par l’arrivée des cartes numériques accessibles depuis les ordinateurs, tablettes et téléphones, bien plus souples à l’usage que les cartes papier.
Les cartes numériques rassemblent toutes les échelles et permettent de montrer différents aspects de la région visualisée sur une seule carte. Les algorithmes de recherche permettent de retrouver sur la carte les endroits en donnant simplement leur nom, et de calculer des itinéraires entre points selon des modes de transports variés.

Repères historiques

Vidéo : Historique de la localisation (2 min 10s)

Le GPS a été créé par les forces armées des États-Unis dans les années 1960, sur demande du président Nixon, et développé par Ivan A. Getting. Il utilise un ensemble de satellites émettant des ondes radio pour la localisation. Le premier satellite a été lancé en 1978, et le système, avec 24 satellites opérationnels, est devenu pleinement fonctionnel en 1995. Initialement militaire, le GPS a été rendu accessible aux civils gratuitement par Reagan en 1983 après une tragédie aérienne. La précision pour les civils s'est améliorée au fil du temps, notamment en 2000 sous Clinton, rendant la technologie largement disponible. Les États-Unis ont continué à améliorer le système, en coopération avec le système européen Galileo. La Russie et la Chine ont développé leurs propres systèmes, GLONASS et Beidou. Bien que très utile, le GPS peut être moins efficace en ville mais peut être complété par d'autres technologies comme la détection de Wi-Fi.

Fonctionnement du GPS, Galileo


Vidéo : KEZAKO- Comment fonctionne un GPS ? (4min 49s)
Vidéo : GPS, comment ça marche ? (7 min 27s)
Vidéo : Galileo - fonctionnement du GPS européen (3 min 33s)

La géolocalisation permet de trouver la position d'un objet ou d'une personne sur une carte grâce à ses coordonnées. Les satellites GPS, équipés d'horloges atomiques très précises, envoient des informations sur leur position et l'heure. Ces données, arrivant à la vitesse de la lumière, permettent au récepteur GPS de calculer sa distance par rapport aux satellites. En utilisant plusieurs satellites, le récepteur peut déterminer sa propre position par trilatération.
Galileo, le système de l'Union européenne, vise une précision de 4 mètres horizontalement et de 8 mètres en altitude une fois pleinement opérationnel.

En ville ou à l'intérieur des bâtiments, où le GPS est moins précis, les téléphones améliorent leur localisation en utilisant les signaux des antennes relais proches. Cette méthode, combinée au GPS, aide à préciser la position. Les antennes relais peuvent aussi aider les téléphones à identifier quels satellites suivre, grâce à l'Assisted GPS (A-GPS), améliorant la rapidité et la précision de la géolocalisation.

Protocole NMEA 0183

Le Système de Positionnement Global (GPS) est un outil indispensable dans la navigation marine, permettant aux navires de déterminer leur position exacte sur les océans. En recevant des signaux de satellites en orbite autour de la Terre, les équipements GPS calculent la longitude, la latitude et parfois l'altitude, facilitant ainsi la navigation précise et sécurisée sur l'eau. Les données GPS, souvent transmises via le protocole NMEA 0183, permettent une intégration fluide avec d'autres systèmes marins pour la planification de route, le suivi et la gestion des risques. Programme Python pour Lire une Trame NMEA 0183

Voici un exemple simple de programme Python qui lit et interprète une trame NMEA 0183 de type GPRMC, qui contient des informations essentielles de navigation comme l'heure, la date, la position et la vitesse.

# Exemple de trame NMEA 0183
trame = '$GPRMC,204311.602,A,3747.3392,N,12223.8954,W,0.50,324.18,061115,,,A*7A'

# Découpe la trame en éléments
elements = trame.split(",")

# Type de trame
type_trame = elements[0][3:]
print("Type de trame =", type_trame)

# Origine du signal (système de navigation)
def origine_signal(trame):
    id = trame[1:3]
    return { "GP": "GPS", "GL": "GLONASS", "GA": "Galileo", "GB": "Beidou" }.get(id, "Inconnu")

print("Origine du signal =", origine_signal(trame))
print("Heure UTC =", elements[1][:2] + " h " + elements[1][2:4] + " min " + elements[1][4:] + " s")
print("Latitude =", elements[3][:2] + "°" + elements[3][2:] + "'" + elements[4])
print("Longitude =", elements[5][:3] + "°" + elements[5][3:] + "'" + elements[6])

OpenStreetMap et GeoPortail



Vidéo : Contribution OpenStreetMap (4 min 42s)
Vidéo : GeoPortail (5 min 36s)
Vidéo : Folium (9 min 26s)

Folium – Python

import folium

def carte(latitude, longitude, zoom, marqueur):
    # Créer une carte centrée sur une certaine position
    carte = folium.Map(location=[latitude, longitude], zoom_start=zoom)

    # Ajouter un marqueur à la position spécifiée
    folium.Marker([latitude, longitude], popup=marqueur).add_to(carte)

    # Enregistrer la carte dans un fichier HTML
    #carte.save('Carte 1.html')
    return carte

carte(43.946,4.853,18,'Lycée René CHAR')
import folium

def carte_satelite(latitude, longitude, zoom, marqueur):
    # Créer une carte centrée sur une certaine position
    carte = folium.Map(location=[latitude, longitude], zoom_start=zoom)

    tile = folium.TileLayer(
        tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
        attr='Esri',
        name='Esri Satellite',
        overlay=False,
        control=True
    ).add_to(carte)

    # Ajouter un marqueur à la position spécifiée
    folium.Marker([latitude, longitude], popup=marqueur).add_to(carte)

    # Enregistrer la carte dans un fichier HTML
    #carte.save('Carte 2.html')
    
    return carte
    
carte_satelite(43.946,4.853,18,'Lycée René CHAR')

Autres exemples : Folium documentation


Quelle est le nom de la station de métro ?
Télécharger l'image : ici
from PIL import Image

def obtenir_lat_lon(photo):
    def convertir_en_decimal(coord, ref):
        d = coord[0].numerator / coord[0].denominator
        m = coord[1].numerator / coord[1].denominator / 60.0
        s = coord[2].numerator / coord[2].denominator / 3600.0
        decimal = d + m + s
        if ref in ['S', 'W']:
            decimal = -decimal
        return decimal

    image = Image.open(photo)
    exif_data = image._getexif()

    if not exif_data or 34853 not in exif_data:
        return None, None

    gps_info = exif_data[34853]
    lat_ref = gps_info.get(1)
    lat = gps_info.get(2)
    lon_ref = gps_info.get(3)
    lon = gps_info.get(4)

    if not (lat and lon and lat_ref and lon_ref):
        return None, None

    latitude = convertir_en_decimal(lat, lat_ref)
    longitude = convertir_en_decimal(lon, lon_ref)

    return latitude, longitude


photo = "Intro_Pieds.jpg"
latitude,longitude = obtenir_lat_lon(photo)
carte(latitude,longitude,18,'Station de métro')
#carte_satelite(latitude,longitude,18,'Station de métro')

PIX : Afficher tracé d'un fichier .gpx

Cliquez ici pour télécharger le fichier GPS_Note.gpx, puis importer le dans basthon.

import folium
from xml.etree import ElementTree as ET

# Charger le fichier GPX et extraire les coordonnées
gpx_path = 'GPS_Note.gpx'
tree = ET.parse(gpx_path)
coords = [(float(pt.attrib['lat']), float(pt.attrib['lon'])) 
          for pt in tree.findall('.//{http://www.topografix.com/GPX/1/1}trkpt')]

# Créer et afficher une carte avec Folium
map = folium.Map(location=coords[0], zoom_start=10)
folium.PolyLine(coords, color='blue').add_to(map)

# Sauvegarder la carte dans un fichier HTML
#map.save('GPS-Track.html'

map

Les ordinateurs, tablettes et téléphones équipés d'applications spécifiques sont principalement utilisés pour la cartographie. Les récepteurs GPS sont encore essentiels pour la navigation en mer et dans les airs, mais sont moins utilisés pour la randonnée, remplacés par les téléphones.
Le GPS aide à synchroniser l'heure des ordinateurs sur internet, important pour les échanges d'informations.
Les cartes numériques sur téléphone remplacent les cartes papier et facilitent l'accès à diverses informations. Le GPS est largement utilisé dans les transports, l'agriculture, et la navigation, entre autres. Mettre à jour les cartes numériques est complexe et coûteux, et les erreurs peuvent être graves.
De plus, beaucoup d'applications sur les téléphones utilisent la localisation pour envoyer des publicités ou suivre les déplacements.

Calculs d’itinéraires

Graph Online est un outil web interactif conçu pour la création, la visualisation et l'étude de graphes et de réseaux. Il permet aux utilisateurs de construire facilement des graphes en ajoutant et connectant des nœuds, puis d'appliquer divers algorithmes pour analyser les propriétés du graphe, telles que la recherche du chemin le plus court avec Dijkstra, ce qui est pertinent pour calculer des itinéraires dans le contexte de la planification de trajet.

Allez-vous amuser sur : Graph Online

Confidentialité

Pour régler le partage ou non de votre position sur un téléphone :

Sur Android :

Sur iOS (iPhone) :

Conseil : Revérifiez périodiquement qui peut voir votre position pour protéger votre vie privée.

import os
repertoire = "."
fichiers = [f for f in os.listdir(repertoire) if os.path.isfile(os.path.join(repertoire, f))]
print(f"fichiers : {fichiers}")

for fichier in fichiers:
    chemin_complet = os.path.join(repertoire, fichier)
    os.remove(chemin_complet)
    print(f"Le fichier {fichier} a été supprimé.")
fichiers : []

Retour au sommaire

08 - Image

Traitement d'images

Dans tout ce notebook, on travaille principalement avec l'image du perroquet, ci-dessous.


Vous pouvez télécharger l'image ici : Perroquet.

Vous pouvez travailler avec votre propre image.
Pour cela, il faut modifier les programmes ci-dessous en indiquant le nom de votre image et joindre votre fichier image à ce notebook.
On utilisera la bibliothèque PIL (Python Imaging Library) qui permet d'agir sur les pixels d'une image.

Les technologies de la photographie argentique ont eu une évolution très lente, liée aux progrès en optique, mécanique et chimie. Ce n’est plus du tout le cas de l’évolution actuelle, davantage due aux algorithmes qu’à la physique : algorithmes de développement et d’amélioration de l’image brute, algorithmes d’aide à la prise de vue. Cet exemple est caractéristique des façons de procéder de la révolution informatique par rapport aux approches traditionnelles. La photographie numérique présente un coût marginal très faible et une diffusion par internet facile et immédiate : chaque jour, des milliards de photos sont prises et partagées.

Repères historiques :

Vidéo : La photographie numérique (2 min 32 s)

1826 : naissance de la photographie argentique ;
1900 : photographie en couleurs. Après la seconde guerre mondiale, généralisation du format 24 x 36 et de la visée reflex ;
1969 : arrivée des premiers capteurs CCD (Charge Coupled Device) ;
1975 : apparition des premiers appareils numériques ;
2007 : arrivée du smartphone

Les principaux formats de fichiers images :

Ils sont très nombreux, aussi, voici les formats les plus courants :

Comment est formée une image ?

Une image en couleur est constituée de trois couches :

Simulation Espace des couleurs RVB : Triangle de Maxwell

Une image est composée de Nl lignes et de Nc colonnes où chaque point est un pixel
Un pixel est un 3-uplet de la forme (valeur Rouge, valeur Verte, valeur Bleu) dont les valeurs vont de 0 à 255.
Le nombre de pixels total est Nl × Nc.

1- Dimensions d'une image

Le programme ci-dessous affiche les dimensions (largeur et hauteur) de l'image en pixels.
Il affiche le nombre total de pixels qui composent l'image.
from PIL import Image

image = Image.open('Perroquet.jpg')
largeur,hauteur = image.size
print("Largeur en pixels : ",largeur," Hauteur en pixels : ",hauteur)
print("Cette image est composée de", largeur * hauteur, "pixels.")
image.show()

<h2 style="text-decoration:underline;" id="partie2";>2- Lire la couleur d'un pixel particulier

Le programme ci-dessous affiche les niveaux de rouge, vert, bleu du pixel de coordonnées (200,100).
Modifier ce programme pour qu'il affiche les niveaux de rouge, vert, bleu du coin supérieur gauche de l'image.

rouge, vert, bleu = image.getpixel((200,100))
print("Rouge : ",rouge," Vert : ",vert," Bleu : ",bleu)

<h2 style="text-decoration:underline;" id="partie3";>3- Modifier la couleur d'un pixel

Le programme modifie la couleur d'un pixel situé sur le bec et attribuer une couleur sombre à ce pixel.
image = Image.open('Perroquet.jpg')
image.putpixel( (260,60), (10,10,10) ) # pixel noir ajouté sur le bec
image.show()

<h2 style="text-decoration:underline;" id="partie4";>4- Modifier la couleur d'une zone rectangulaire

Le programme ci-dessous affiche un carré noir sur l'image. 
image = Image.open('Perroquet.jpg')
for x in range(350,450):
    for y in range(200,250):
        image.putpixel((x,y),(0,0,0))
image.show()

<h2 style="text-decoration:underline;" id="partie5";>5- Afficher que le rouge

Le programme ci-dessous ne garde que le rouge de l'image. 
from PIL import Image

image = Image.open('Perroquet.jpg')
largeur, hauteur = image.size 

for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))  
        nouveauRouge = rouge
        nouveauVert = 0
        nouveauBleu = 0
        image.putpixel( (x, y), (nouveauRouge,nouveauVert,nouveauBleu) )
image.show()
Question PIX : Quel est le mot caché ?
Vous pouvez télécharger l'image ici : PIX

<h2 style="text-decoration:underline;" id="partie6";>6- Assombrir une image

Le programme affiche une version assombrie de l'image en divisant par 2 les niveaux de rouge/vert/bleu de chaque pixel. 
from PIL import Image

def f(x):
    return x // 2

image = Image.open('Perroquet.jpg')
largeur, hauteur = image.size 

for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))  
        nouveauRouge = f(rouge)
        nouveauVert = f(vert)
        nouveauBleu = f(bleu)
        image.putpixel( (x, y), (nouveauRouge,nouveauVert,nouveauBleu) )
image.show()

<h2 style="text-decoration:underline;" id="partie7";>7- Eclaircir une image

1) Le programme 1 claricit l'image en multipliant par 2 les niveaux de rouge/vert/bleu de chaque pixel.
2) Le programme 2 est une ammélioration du programme 1. 
# Programme 1

from PIL import Image
import math

image = Image.open('Perroquet.jpg')
largeur, hauteur = image.size 
for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))  
        nouveauRouge = rouge * 2
        nouveauVert = vert * 2
        nouveauBleu = bleu * 2
        image.putpixel( (x, y), (nouveauRouge,nouveauVert,nouveauBleu) )
image.show()
# Programme 2

# Le problème est qu'après multiplication par 2, les valeurs des niveaux de rouge/vert/bleu risquent de 
# dépasser la valeur maximale 255. PIL choisit dans ce cas de fixer le niveau à la valeur plafond 255, 
# ce qui donne un image saturée (avec des zones entièrement blanches).

# Pour remédier à cela, on peut utiliser la fonction "racine carrée" qui, du fait de sa concavité,
# va beaucoup augmenter les valeurs faibles et seulement légèrement augmenter les valeurs élevées.
# Avec f(x) = racine(255*x) on a : f(0) = 0 (le noir reste noir)
#                                  f(255) = 255 (le blanc reste blanc)
#                                  f(10) = 50 (une valeur faible est multipliée par 5) 
#                                 f(250) = 252 (une valeur élevée n'est que très peu augmentée)
# Ainsi, le résultat obtenu est bien meilleur.

from PIL import Image
import math

def f(x):
    return int(math.sqrt(255*x))  # f(x)=racine(255*x) et on convertit le résultat en entier

image = Image.open('Perroquet.jpg')
largeur, hauteur = image.size 
for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))  
        nouveauRouge = f(rouge)
        nouveauVert = f(vert)
        nouveauBleu = f(bleu)
        image.putpixel( (x, y), (nouveauRouge,nouveauVert,nouveauBleu) )
image.show()

<h2 style="text-decoration:underline;" id="partie8";>8- Transformer une image couleur en noir et blanc

Le programme transforme les couleurs de l'image en niveaux de gris, de façon à ce que l'image apparaisse en "noir et blanc".
Indication : pour qu'un pixel apparaisse "gris", ses niveaux de rouge/vert/bleu doivent être identiques.
from PIL import Image

image = Image.open('Perroquet.jpg')
largeur,hauteur = image.size 
for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))  
        moyenne = int(0.2125 * rouge + 0.7154 * vert + 0.0721 * bleu) # Gris Normalisé
        # moyenne = (rouge + vert + bleu) // 3  # Autre méthode : moyenne des 3 niveaux de couleur RVB
        nouveauRouge = moyenne
        nouveauVert = moyenne
        nouveauBleu = moyenne
        image.putpixel( (x, y), (nouveauRouge,nouveauVert,nouveauBleu) )
image.show()

<h2 style="text-decoration:underline;" id="partie9";>9- Obtenir le négatif d'une image

Le programme transforme une image en son négatif, pour cela il transforme les pixels clairs en pixels sombres et inversement. 
from PIL import Image

# on transforme chaque niveau de couleur avec la fonction définie par f(x) = 255 - x 
#  f(0) = 255   et f(255) = 0     Le sombre devient clair et le clair devient sombre.

def f(x):
    return 255- x

image = Image.open('Perroquet.jpg')
largeur,hauteur = image.size 
for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))         
        nouveauRouge = f(rouge)
        nouveauVert = f(vert)
        nouveauBleu = f(bleu)
        image.putpixel( (x, y), (nouveauRouge,nouveauVert,nouveauBleu) )
image.show()

<h2 style="text-decoration:underline;" id="partie10";>10- L'effet miroir

Un programme transforme l'image en son reflet dans un miroir, en inversant la gauche et la droite. 
from PIL import Image

image = Image.open('Perroquet.jpg')
imageDestination = Image.open('Perroquet.jpg')
largeur,hauteur = image.size 

for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))            
        imageDestination.putpixel( (largeur-1-x, y), (rouge, vert, bleu) )
imageDestination.show()
from PIL import Image

image = Image.open('Perroquet.jpg')
imageDestination = Image.open('Perroquet.jpg')
largeur,hauteur = image.size 

for x in range(largeur): 
    for y in range(hauteur):
        rouge,vert,bleu = image.getpixel((x,y))            
        imageDestination.putpixel( (x,hauteur-1-y), (rouge, vert, bleu) )
imageDestination.show()

<h2 style="text-decoration:underline;" id="partie11";>11- Insérer une image dans une image

Le programme colle l'image du chat en fond transparent ci-dessous sur l'image du perroquet.

Vous pouvez télécharger l'image ici : Cat.

Cette image a une quatrième couche qui corresponds à la transparence.
from PIL import Image

sprite = Image.open('Photo cat.png')
fond = Image.open('Perroquet.jpg')
largeur,hauteur = sprite.size
for x in range(largeur):  
    for y in range(hauteur):          
        rouge, vert, bleu, transparence = sprite.getpixel( (x,y) )       
        if transparence == 255 : # si le pixel est transparent
            fond.putpixel( (x,y+154), (rouge, vert, bleu) ) # les 154 servent à déplacer le chat en bas de l'image    
fond.show()

<h2 style="text-decoration:underline;" id="partie12";>12- Créer une vache Milka

Le programme va, à partir de la photographie d'une vache, la transformer en vache Milka.

Vous pouvez télécharger l'image ici : vache.
from PIL import Image

image = Image.open('vache.jpg')
image.show()

largeur,hauteur = image.size
for x in range(largeur):  
    for y in range(hauteur):          
        rouge, vert, bleu = image.getpixel( (x,y) )       
        if rouge + vert + bleu < 200: # si le pixel est sombre
            if  70<x<655 and 50<y<300: # si le pixel est dans le rectangle qui contient la vache
                     image.putpixel( (x,y), (rouge+65,vert+15,bleu+85) ) # lui ajouter du violet (beaucoup mieux!)
image.show()

<h2 style="text-decoration:underline;" id="partie13";>13- Faire apparaître les contours d'une image

from PIL import Image

imageSource = Image.open('Perroquet.jpg')
imageDestination = Image.open('Perroquet.jpg')
largeur,hauteur = imageSource.size

def f(i):
    return abs(imageSource.getpixel((x-1,y))[i] - imageSource.getpixel((x+1,y))[i]) + abs(imageSource.getpixel((x,y-1))[i] - imageSource.getpixel((x,y+1))[i])

for x in range(1,largeur-1):
    for y in range(1,hauteur-1):
        écartRouge = f(0)
        écartVert = f(1)
        écartBleu = f(2)   
        écart = écartRouge + écartVert + écartBleu
        imageDestination.putpixel((x,y),(255-écart,255-écart,255-écart))
imageDestination.show()

<h2 style="text-decoration:underline;" id="partie14";>14- Superposition d'images


Vous pouvez télécharger les images ici : Avion, Porte Avions.
from PIL import Image

image1 = Image.open('Photo Avion.jpg')
image2 = Image.open('Photo Porte Avions.jpg')
largeur,hauteur = image1.size 
for x in range(largeur): 
    for y in range(hauteur):
         rouge1,vert1,bleu1 = image1.getpixel((x,y)) 
         rouge2,vert2,bleu2 = image2.getpixel((x,y)) 
         rouge = max(rouge1,rouge2)
         vert = max(vert1,vert2)
         bleu = max(bleu1,bleu2)
         image1.putpixel( (x, y), (rouge,vert,bleu) )
image1.show()






import os
repertoire = "."
fichiers = [f for f in os.listdir(repertoire) if os.path.isfile(os.path.join(repertoire, f))]
print(f"fichiers : {fichiers}")

for fichier in fichiers:
    chemin_complet = os.path.join(repertoire, fichier)
    os.remove(chemin_complet)
    print(f"Le fichier {fichier} a été supprimé.")

Merci, Thomas FOIRIEN !

Retour au sommaire

09 - Python

Programmer en langage Python

Les modules

Les modules Python sont des bibliothèques contenant un ensemble de fonctions et de variables qui peuvent être importées dans d'autres programmes pour fournir des fonctionnalités supplémentaires sans avoir à réécrire du code.

Parmi les modules fréquemment utilisés, on trouve :

Pour identifier les modules disponibles dans l'environnement Python actuel, la commande help('modules') peut être utilisée, affichant ainsi tous les modules accessibles, y compris les modules intégrés à Python. En parallèle, la commande pip freeze dans le terminal liste tous les paquets Python installés avec leurs versions spécifiques. Cette dernière est particulièrement utile pour la gestion des dépendances et le partage d'environnements de développement, permettant de recréer un environnement Python identique sur différents systèmes ou environnements virtuels.

from mpmath import mp
mp.dps = 500
print(mp.pi)
import numpy as np
import matplotlib.pyplot as plt
plt.clf()
x = np.linspace(-5, 5, 100)
y1 = x**2
y2 = x**3
plt.plot(x, y1, label='y = x^2')
plt.plot(x, y2, label='y = x^3')
# Ajout des axes
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)

plt.grid(True)
plt.legend()
plt.show()

Opérations de base en Python

2**4
7/2
7//3
7%3
46546547987987654*5465465479879879865465
0.1 + 0.2

⚠ Lorsque vous additionnez 0.1 et 0.2, l'ordinateur travaille avec les représentations binaires les plus proches de ces nombres, qui ne peuvent pas être exactement égales à 0.1 et 0.2 en base 10. Le résultat de cette addition est donc légèrement différent de 0.3

Variables, affectations, calculs

En Python, l'affectation de valeur à des variables, leur manipulation à travers des calculs, et l'échange de leurs valeurs sont des opérations fondamentales. Voici un résumé des concepts clés :

Il est crucial de noter que input() renvoie une chaîne de caractères. Par conséquent, si vous effectuez une opération arithmétique directement sur une valeur saisie via input(), le comportement sera celui d'une opération sur des chaînes de caractères, sauf si une conversion de type est appliquée au préalable pour obtenir un entier (int()) ou un nombre décimal (float()).

# Affectation initiale des valeurs
a = 10
b = 5
print("Valeurs initiales : a =", a, "b =", b)

# Echange des valeurs de a et b
a, b = b, a
print("Valeurs échangées : a =", a, "b =", b)

# Affectation de valeurs avec différents types
d, e = 10, 4.3
print("d =", d, "e =", e)

# Lire une chaîne de caractères
texte = input("Entrez un texte : ")
print("Texte saisi :", texte)

# Lire une valeur entière
x = int(input("Valeur de x (entier) ? "))
print("2x =", 2 * x)

# Lire une valeur décimale
y = float(input("Valeur de y (décimal) ? "))
print("2y =", 2 * y)

# Périmètre du rectangle
longueur = float(input("longueur = "))
largeur = float(input("largeur = "))
périmètre = 2*longueur+2*largeur
print ("périmètre rectangle = ",périmètre)

Les tests conditionnels if

Un bloc de code associé à une condition est délimité par l'indentation (décalage vers la droite des lignes). Chaque ligne du bloc conditionnel doit être indentée de la même manière.

Test Simple (if)

if condition:
    instructions
a = int(input("Donnez un nombre : "))
if a < 10:
    print("Ce nombre est inférieur à 10")

Test Complet (if...else)

if condition:
    instructions
else:
    instructions
a = float(input("Donnez un autre nombre : "))
if a < 10:
    print("Ce nombre est inférieur à 10")
else:
    print("Ce nombre est supérieur ou égal à 10")

Tests Multiples (if...elif...else)

if condition1:
    instructions
elif condition2:
    instructions
else:
    instructions
nb_personne = int(input("Nombre de personnes ? "))
if nb_personne <= 2:
    prix = nb_personne * 15
elif nb_personne == 3:
    prix = nb_personne * 15 * 0.8
else:
    prix = nb_personne * 15 * 0.7
print("Prix à payer :", prix)

Comparaisons

Double Inégalité

a = float(input("Donnez un 4e nombre : "))
if a < 10:
    print("Ce nombre a 1 chiffre")
else:
    if a < 100:
        print("Ce nombre a 2 chiffres")
    else:
        print("Ce nombre a 3 chiffres ou plus")

Les boucles itératives for

Les boucles itératives for en Python sont utilisées pour parcourir une séquence (comme une liste, un tuple, une chaîne de caractères) ou tout autre objet itérable, en exécutant un bloc d'instructions pour chaque élément de la séquence.

for variable in séquence:
    instructions

La fonction range

La fonction range() est souvent utilisée avec les boucles for pour générer une séquence de nombres.

list(range(6, 22, 4))
list(range(1,20))
list(range(20))

Exemples d'utilisation de for

for i in range(5):
    print(i, "a pour carré", i**2)
for i in range(10, 5, -1):
    print(i, "a pour carré", i**2)
for i in [2, 5, 6, 8, 4]:
    print(i, "a pour carré", i**2)
for elts in 'Bonjour':
    print(elts)
n = 50
résultat =[]
for x in range(1, n):
    for y in range(1, n):
        for z in range(1, n):
         if x**2 + y**2 == z**2 and x<=y:
            résultat = résultat+ [(x,y,z)]
print(résultat)

Boucles conditionnelles while

Les boucles conditionnelles while en Python permettent d'exécuter un bloc d'instructions tant qu'une condition donnée est vraie. C'est un outil puissant pour répéter des opérations jusqu'à ce qu'une condition spécifique soit remplie. Structure Générale

La structure d'une boucle while est similaire à celle d'un test conditionnel if, mais avec une différence clé : au lieu d'exécuter le bloc d'instructions une seule fois si la condition est vraie, la boucle while continue de répéter le bloc tant que la condition reste vraie.

while condition:
    instructions

Il est crucial d'initialiser au préalable la variable qui sera testée dans la condition de la boucle while, pour éviter une boucle infinie.

Dans cet exemple, on initialise une variable i à 10. Ensuite, une boucle while est utilisée pour décompter jusqu'à 0, imprimant chaque valeur de i. Lorsque i atteint 0, la boucle se termine et le programme imprime "Boum !".

i = 10  # Initialisation de la variable
while i != 0:  # La boucle s'exécute tant que i est différent de 0
    print(i)
    i = i - 1  # Décrémentation de i pour éviter une boucle infinie
print("Boum !")  # Ce message s'affiche une fois la boucle terminée
import random
import time

nb = random.randint(0, 10)
gagne = 0
coups = 0
début = time.time()

while gagne == 0:
    N = int(input("Entrer un nombre : "))
    coups += 1
    if N < nb:
        print("Trop petit")
    elif N > nb:
        print("Trop grand")
    else:
        print("Vous avez gagné !")
        gagne = 1

fin = time.time()
print("Le nombre cherché est bien :", nb, ".")
print("Vous avez trouvé en", coups, "coups et", fin - début, "s.")
somme = 1000
mensualité = 130
augmentationmensuelle = 1.02**(1/12)
mois = 0

while somme > 0:
    mois += 1
    somme = augmentationmensuelle * somme - mensualité
    print(mois, "mois :", round(somme, 2), "€")

Les fonctions en Python def

Les fonctions en Python sont des blocs de code réutilisables conçus pour effectuer une tâche spécifique. Elles sont définies avec le mot-clé def suivi du nom de la fonction, des parenthèses contenant les paramètres (si nécessaires) et d'un deux-points (:). Le corps de la fonction est indenté et peut renvoyer une valeur à l'aide de return.

Points Clés

Les fonctions permettent de structurer le code, d'éviter les répétitions et de rendre le programme plus lisible et maintenable.

def f(x):
    return 2*x**2 + 3

# Affichage des valeurs de la fonction pour i de 0 à 10
for i in range(11):
    print("f(", i, ") = ", f(i))
def mil(x1, y1, x2, y2):
    return [(x1+x2)/2, (y1+y2)/2]

# Saisie des coordonnées des points A et B
xa = float(input("xA = "))
ya = float(input("yA = "))

# Utilisation de 'input' directement pour la cohérence
xb = float(input("xB = "))
yb = float(input("yB = "))

# Calcul du milieu
I = mil(xa, ya, xb, yb)

# Affichage du milieu
print("Milieu I de [AB] : I(", I[0], ",", I[1], ")")
from numpy import linspace, reshape
from matplotlib import pyplot as plt

xmin, xmax = -2.0, 0.5    
ymin, ymax = -1.25, 1.25  
nx, ny = 100, 100       
maxiter = 50              

def mandelbrot(z):
    c = z
    for n in range(maxiter):
        if abs(z) > 2:
            return n  
        z = z*z + c
    return maxiter

X = linspace(xmin, xmax, nx)
Y = linspace(ymin, ymax, ny)

N = []
for y in Y:
    for x in X:
        z = complex(x, y)
        N.append(mandelbrot(z))

N = reshape(N, (ny, nx))

plt.imshow(N, extent=(xmin, xmax, ymin, ymax))  
plt.colorbar()  
plt.title("Ensemble de Mandelbrot")  
plt.xlabel("Re")  
plt.ylabel("Im")  
plt.show()

Retour au sommaire

10 - Nos scripts

Programmes en langage Python

#01 : Périmètre d’un rectangle

longueur = float(input("longueur du rectangle = "))
largeur = float(input("largeur du rectangle = "))
print("Le périmètre du rectangle est de : ", 2*longueur + 2* largeur)
longueur du rectangle = 5
largeur du rectangle = 4
Le périmètre du rectangle est de :  18.0

#02 : La boulangerie

print("Un pain au chocolat coûte 0.90€.")
print("Un croissant coûte 0.80€.")
print("Un café coûte 1€.")

pac=float(input("Combien prenez vous de pain au chocolat ? "))
c=float(input("Combien prenez vous de croissant ? "))
ca=float(input("Combien prenez vous de café ? "))

print("Le prix total est de",pac*0.90+c*0.80+ca*1,"€.")
Un pain au chocolat coûte 0.90€.
Un croissant coûte 0.80€.
Un café coûte 1€.
Combien prenez vous de pain au chocolat ? 2
Combien prenez vous de croissant ? 3
Combien prenez vous de café ? 2
Le prix total est de 6.2 €.

#03 : Le triangle est-il rectangle ?

print('Donnez les longueurs de votre triangle ABC.')
print('Attention : nombres entiers !!!')

AB = int(input("AB = "))
AC = int(input("AC = "))
BC = int(input("AC = "))

if AB**2 + AC**2 == BC**2:
    print("Le triangle ABC est rectangle en A.")
if AB**2 + BC**2 == AC**2:
    print("Le triangle ABC est rectangle en B.")
if BC**2 + AC**2 == AB**2:
    print("Le triangle ABC est rectangle en C.")
Donnez les longueurs de votre triangle ABC.
Attention : nombres entiers !!!
AB = 3
AC = 4
AC = 5
Le triangle ABC est rectangle en A.

#04 : Table de multiplication de 0 à 2

a = 9
for i in range(0,11):
     print(a,'x',i,' = ',a*i)
9 x 0  =  0
9 x 1  =  9
9 x 2  =  18
9 x 3  =  27
9 x 4  =  36
9 x 5  =  45
9 x 6  =  54
9 x 7  =  63
9 x 8  =  72
9 x 9  =  81
9 x 10  =  90

#05 : Somme S = 1 + 2 + 3 + ... + 1000

S = 0
for i in range(0,1001):
    S = S + i
print(S)
500500

#06: Programme Seuil - Crédit immobilier

Emprunt = 200000 # soit 200 000€
taux_par_an = 2 # c'est-à-dire 2%
mensualité = 1000 # remboursement 1000€/mois
coef_augmentation_par_mois = (1 + taux_par_an/100)**(1/12)
mois = 0

while Emprunt > 0:
    Emprunt = Emprunt * coef_augmentation_par_mois - mensualité
    mois = mois + 1
print("nombre de mois = ",mois, 'mois')
print("nombre d'années = ",mois/12, 'ans')
print('Emprunt =', Emprunt, "€")
nombre de mois =  243 mois
nombre d'années =  20.25 ans
Emprunt = -32.39060404096074 €

#07 : Jeu - Le juste Prix

import random
nb = random.randint(1,10)
a=-1
while nb != a:
    a = int(input("Donnez un nombre :"))
    if a<nb:
        print("Votre nombre est trop petit.")
    if a>nb:
        print("Votre nombre est trop grand.")
print("Bravo, le nombre était bien : ",nb)
Donnez un nombre :5
Votre nombre est trop petit.
Donnez un nombre :7
Votre nombre est trop petit.
Donnez un nombre :9
Bravo, le nombre était bien :  9

#08: Programme Seuil - S = 1 + 1/2 + 1/3 + 1/4 + 1/5 + ...

seuil = 5  # Définissez le seuil souhaité ici
somme = 0
nombre_de_termes = 0

while somme < seuil:
    nombre_de_termes += 1
    somme += 1 / nombre_de_termes

print(f"S = 1 + 1/2 + 1/3 + 1/4 + 1/5 + ... + 1/{nombre_de_termes} = {somme} ")
S = 1 + 1/2 + 1/3 + 1/4 + 1/5 + ... + 1/83 = 5.002068272680166 

#09: Dichotomie

def f(x):
    return x**2 - 2

a = 0
b = 2
ya = f(a)

while b - a > 1e-15:
    m = (a + b) / 2
    if ya*f(m) > 0:
        a = m
    else:
        b = m

print('a =', a)
print('b =', b)
a = 1.414213562373095
b = 1.4142135623730958

#10 : Tableau de valeurs

import numpy as np
import pandas as pd

# Définition des fonctions
def f(x):
    return 3*x**2 - 2*x - 1

def g(x):
    return 2*x - 1

# Générer les valeurs de x
x = np.linspace(-5, 5, 11)  # 11 pour le nombre de valeurs

# Création d'un DataFrame pandas pour organiser les valeurs
data = {'x': x, 'f(x)': f(x), 'g(x)': g(x)}
df = pd.DataFrame(data)

# Afficher le DataFrame
print(df)
      x  f(x)  g(x)
0  -5.0  84.0 -11.0
1  -4.0  55.0  -9.0
2  -3.0  32.0  -7.0
3  -2.0  15.0  -5.0
4  -1.0   4.0  -3.0
5   0.0  -1.0  -1.0
6   1.0   0.0   1.0
7   2.0   7.0   3.0
8   3.0  20.0   5.0
9   4.0  39.0   7.0
10  5.0  64.0   9.0

#11 : Graphique

import matplotlib.pyplot as plt
import numpy as np

def f(x) :
    return 3*x**2-2*x-1

def g(x) :
    return 2*x-1

plt.clf()
plt.axis([-5,5,-10,20])
plt.grid()

x = np.linspace(-5,5,100)

plt.plot(x,f(x))
plt.plot(x,g(x))

# Dessiner les axes
plt.axhline(0, color='black', lw=2)
plt.axvline(0, color='black', lw=2)

plt.show()

Retour au sommaire

14 - Base Python

Bases du langage Python

  1. Nombres et calculs
  2. Variables et affectations
  3. Chaînes de caractères
  4. Saisie de l'entrée utilisateur

On présente ici les bases du langage Python : calculs, variables, affichage, saisie, type de données. Les fonctionnalités un peu plus avancées telles que les instructions conditionnelles, les boucles, les fonctions ou les listes seront étudiées dans les prochains chapitres.

Le langage Python a été créé par le néerlandais Guido van Rossum en 1991.
Parmi les avantages du langage Python, on peut citer :

Si le langage Python n'avait que des avantages, les autres langages concurrents auraient disparu. Le principal défaut de Python est sa relative lenteur par rapport à d'autres langages comme C/C++ ou Java. La vérification des types peut aussi poser quelques problèmes au niveau de la fiabilité des programmes (pas de compilation préalable donc détection de certaines erreurs au moment de l'exécution seulement) et de la maintenance. Enfin ce langage est peu adapté à la programmation sur smartphone.

1- Nombres et calculs

Python permet d'effectuer tout type de calcul, comme une calculatrice ordinaire.

5 + 8

Les règles de priorité des calculs sont les mêmes qu'en mathématiques. On utilise des parenthèses lorsqu'on a besoin de changer l'ordre de priorité. Le symbole de la multiplication est * (afin qu'il n'y ait pas de confusion avec la lettre x).

Exercice 1 : Dans une école, il y a trois classes :
Chaque élève de l'école doit recevoir 192 photocopies.
Combien faut-il prévoir de photocopies en tout ?

Une des particularités du langage Python est que le nombre de chiffres n'est pas limité pour les nombres entiers.

Exercice 2 : Calculer le produit de deux nombres à 10 chiffres.

Pour calculer une puissance, on utilise la notation . Par exemple pour calculer 7 au carré, on écrira 72.

Exercice 3 : Calculer 6 au cube de deux manières différentes : en utilisant une puissance et sans utiliser de puissance.

Types numériques

Il existe deux types de nombres en Python : les entiers (int, abréviation de "integer") et les flottants (float, abréviation de "floating number" qui signifie "nombre à virgule flottante").

La fonction type() indique le type du nombre qu'on lui donne en paramètre :

type(5)
type(5.0)

La division

Il existe deux types de division en Python : la division entière avec l'opérateur // et la division flottante avec l'opérateur / .
L'opérateur % permet d'obtenir le reste dans une division entière.

13 // 5
13 / 5
13 % 5
Exercice 4 : En utilisant les opérateurs précédents, écrire 437 secondes au format minutes:secondes.

Nombre de minutes :

Nombre de secondes :

Nombres aléatoires

Les fonctions concernant les nombres aléatoires ne font pas partie des fonctions de base du langage Python. Pour pouvoir les utiliser, on doit commencer par donner l'accès à une bibliothèque de fonctions appelée random ("random" signifie "aléatoire") au moyen de l'instruction import random.

import random
random.randint(4,7)  # Ceci renvoie un entier choisi au hasard entre 4 et 7 inclus

On peut aussi importer toutes les fonctions de la bibliothèque random d'un seul coup, ce qui permet d'éviter d'écrire le préfixe random. lorsqu'on utilise une de ces fonctions :

from random import *
randint(2,9)
Exercice 5 : Simuler le lancer de deux dés et afficher la somme obtenue.

La fonction random() renvoie une nombre aléatoire compris entre 0 et 1, de type float :

random() # nombre aléatoire compris entre 0 et 1 
random() * 8 # nombre aléatoire compris entre 0 et 8 (de type float)

2- Variables et affectations

On peut conserver ou stocker un nombre ou le résultat d'un calcul dans une variable.

a = 2    # on affecte la valeur 2 à la variable a
b = 5
c = a + b
a = 3
c

Le contenu des variables persiste en mémoire :

a

Afficher une variable qui n'a pas encore été définie ou déclarée provoque une erreur :

d
Exercice 6 : Ecrire un algorithme qui échange le contenu des variables a et b ci-dessous (trois lignes à compléter). 
a = 7
b = 4
...
...
...
a
b
Exercice 7 : Quel est le rôle de l'algorithme ci-dessous ? Prouvez-le!
a = 7
b = 4
a = a + b
b = a - b
a = a - b
a
b

Syntaxe abrégée
On a souvent besoin d'incrémenter une variable (augmenter sa valeur de 1) ou de la décrémenter (diminuer sa valeur de 1).
Au lieu d'écrire a = a + 1, on peut écrire de façon plus courte : a += 1.
Cette syntaxe raccourcie fonctionne pour n'importe quelle valeur de l'incrément, ainsi que pour les opérateurs + , - , *, / , // et %.

Exercice 8 : En utilisant la syntaxe abrégée, ajouter 37 à la variable a ci-dessous, puis multiplier sa valeur par 2.
a = 9
...
...

<h2 style="text-decoration:underline;" id="partie3";>3- Chaînes de caractères

La fonction print() permet d'afficher une chaîne de caractères ("string" en anglais). La chaîne de caractère que l'on souhaite afficher doit être écrite entre guillemets (simples ' double " ou triples '''). Sans guillemets, c'est le contenu de la variable dont le nom est transmis en paramètre qui sera affiché.

bonjour = 8
print("bonjour")
print(bonjour)
Exercice 9 : Ecrire une ligne de programme qui affiche le message "Au revoir!".

Une variable peut contenir une chaîne de caractères :

message = "coucou"
print(message)
type(message)

On peut afficher plusieurs chaînes de caractères à l'aide d'une seule instruction print(). Par défaut, un espace sera inséré entre chaque chaîne :

age = 32
print("Vous avez",age,"ans.")

Plutôt qu'un espace, on peut insérer :

print("Victor","Léa","Ninon",sep=";")     # le séparateur sera le caractère point-virgule (;)
print("Victor","Léa","Ninon",sep=" et ")
print("Victor","Léa","Ninon",sep="")      # aucun sépérateur, ps même un espace
print("Victor","Léa","Ninon",sep="\n")
Exercice 10 : Ecrire un instruction qui affiche une liste de courses séparées par un tiret.

Si on ne souhaite pas passer à la ligne suivante pour la prochaine instruction print, on peut l'indiquer au moyen du paramètre end="" :

print("Victor")
print("Léa")
print("Ninon")
print("Victor",end="")
print("Léa",end="")
print("Ninon")

On peut concaténer (fusionner) plusieurs chaînes de caractère au moyen de l'opérateur + :

message1 = "Bonjour "
message2 = "Madame"
message3 = message1 + message2
print(message3)
message3 += "!"    # la syntaxe abrégée fonctionne aussi pour la concaténation de chaînes de caractères
print(message3)

On ne peut pas concaténer une chaîne de caractères avec une valeur numérique directement. Il faut au préalable transformer la valeur numérique en chaîne de caractères au moyen de la fonction str() :

âge = 25
début = "J'ai "
fin = " ans."
phrase = début + str(âge) + fin
print(phrase)

<h2 style="text-decoration:underline;" id="partie4";>4- Saisie de l'entrée utilisateur

On peut demander à l'utilisateur de saisir une valeur avec la fonction input(). On peut ajouter en paramètre facultatif un message qui donne des précisions sur la valeur attendue :

a = input()
b = input("Entrez votre âge : ")

La valeur renvoyée par la fonction input() est du type chaîne de caractères (string). Si on souhaite utiliser cette valeur pour effectuer des calculs, on doit d'abord convertir cette chaîne en entier avec la fonction int() ou en flottant avec la fonction float() :

réponse = input("Veuillez entre votre âge :")
âge = int(réponse)
âge += 5
print("Dans 5 ans, vous aurez",âge,"ans")
Exercice 11 : Ecrire un programme qui demande à l'utilisateur d'entrer le rayon d'un cercle et qui affiche son périmètre.
_Le programme doit fonctionner pour des valeurs non entières du rayon, et devra afficher une phrase de réponse complète se terminant par un point_. 
import math
math.pi

Merci, Thomas FOIRIEN !

Retour au sommaire

15 - Base Python Correction

Bases du langage Python (Correction)

  1. Nombres et calculs
  2. Variables et affectations
  3. Chaînes de caractères
  4. Saisie de l'entrée utilisateur

1- Nombres et calculs

Exercice 1 : Dans une école, il y a trois classes :
Chaque élève de l'école doit recevoir 192 photocopies.
Combien faut-il prévoir de photocopies en tout ? 
(32 + 27 + 34) * 192
17856
Exercice 2 : Calculer le produit de deux nombres à 10 chiffres. 
1234567891 * 9876543219
12193263132251181129
Exercice 3 : Calculer 6 au cube de deux manières différentes : en utilisant une puissance et sans utiliser de puissance. 
6 ** 3
216
6 * 6 * 6
216

La division

Exercice 4 : En utilisant les opérateurs précédents, écrire 437 secondes au format minutes:secondes.

Nombre de minutes :

437 // 60
7

Nombre de secondes :

437 % 60
17
Donc  437 secondes = 7 minutes et 17 secondes

Nombres aléatoires

Exercice 5 : Simuler le lancer de deux dés et afficher la somme obtenue. 
print(randint(1,6) + randint(1,6))
9

2- Variables et affectations

Exercice 6 : Ecrire un algorithme qui échange le contenu des variables a et b ci-dessous (trois lignes à compléter). 
a = 7
b = 4
c = a  # c est une variable auxiliaire ou temporaire
a = b
b = c
a
4
b
7
Exercice 7 : Quel est le rôle de l'algorithme ci-dessous ? Prouvez-le!
a = 7
b = 4
a = a + b
b = a - b
a = a - b

Cet algorithme échange le contenu des variables a et b. Preuve : Notons x et y les valeurs initiales des variables a et b. Le tableau ci-dessous donne les valeurs successives des variables a et b :

Etape a b
Initialisation x y
a = a + b x+y y
b = a - b x+y x
a = a - b y x

Remarque : Cet algorithme ne fonctionne qu'avec des variables numériques (int et float) et pas avec des chaînes de caractères.
Son intérêt est qu'il n'a pas recours à une variable auxiliaire.

a
4
b
7

Syntaxe abrégée
On a souvent besoin d'incrémenter une variable (augmenter sa valeur de 1) ou de la décrémenter (diminuer sa valeur de 1).
Au lieu d'écrire a = a + 1, on peut écrire de façon plus courte : a += 1.
Cette syntaxe raccourcie fonctionne pour n'importe quelle valeur de l'incrément, ainsi que pour les opérateurs + , - , *, / , // et %.

Exercice 8 : En utilisant la syntaxe abégée, ajouter 37 à la variable a ci-dessous, puis multiplier sa valeur par 2.
a = 9
a += 37
a *=2

<h2 style="text-decoration:underline;" id="partie3";>3- Chaînes de caractères

Exercice 9 : Ecrire une ligne de programme qui affiche le message "Au revoir!". 
print("Au revoir!")
Au revoir!

Une variable peut contenir une chaîne de caractères :

Exercice 10 : Ecrire un instruction qui affiche une liste de courses séparées par un tiret. 
print("jambon","pain","beurre",sep="-")
jambon-pain-beurre

<h2 style="text-decoration:underline;" id="partie4";>4- Saisie de l'entrée utilisateur

Exercice 11 : Ecrire un programme qui demande à l'utilisateur d'entrer le rayon d'un cercle et qui affiche son périmètre.
_Le programme doit fonctionner pour des valeurs non entières du rayon, et devra afficher une phrase de réponse complète se terminant par un point_. 
import math

réponse = input("Quel est le rayon du cercle ? ")
rayon = float(réponse)
périmètre = 2 * math.pi * rayon
print("Le périmètre du cercle est ",périmètre,".",sep="",end="\n")
Quel est le rayon du cercle ? 4.1
Le périmètre du cercle est 25.7610597594363.

Retour au sommaire

16 - if

Conditions, tests et booléens

  1. Les conditions
  2. Les booléens
  3. Les conditions multiples

Les conditions nous permettent de rendre nos programmes adaptatifs en leur donnant la possibilité de se comporter différemment selon qu'une certaine condition est réalisée ou pas.

1- Les conditions

Structure conditionnelle de base : _si ... alors ... sinon ..._

Pseudo-code : instructions A Si condition vraie faire : instructions B Sinon instructions C instructions D
En Python, les mot-clés sont if (si) et else (sinon) : A if condition : B else: C D

Le programme ci-dessous adapte son comportement à la réponse fournie par l'utilisateur :

âge = int(input("Veuillez entrer votre âge ! "))
if âge >= 18:
    print("Vous êtes majeur!")
else:
    print("Vous êtes mineur!")
print("Au revoir!")
Exercice 1 : Il faut mesurer au moins 1m30 pour pouvoir entrer dans un parc d'attractions.
Ecrire un programme qui demande à l'utilisateur sa taille en cm, et qui lui indique s'il peut ou non rentrer dans le parc.
Exercice 2 : Ecrire un programme qui demande à l'utilisateur de saisir deux nombres, puis qui affiche le plus grand de ces deux nombres.
Exercice 3 : Ecrire un programme qui demande à l'utilisateur de saisir un nombre (positif ou négatif), puis qui affiche la valeur absolue de ce nombre.

Voici les différents tests possibles :

SymboleSignification
==égal à
!=différent de
$<$strictement supérieur à
$>$strictement inférieur à
$<=$inférieur ou égal à
$>=$supérieur ou égal à

Attention à la différence entre = et ==
Le symbole = est réservé pour l'affectation.
Le symbole == sert à comparer deux valeurs, plus précisément à savoir si deux valeurs sont égales.
Cette confusion est une importante source de bug chez les débutants en programmation.

Exercice 4 : Ecrire un programme qui demande à l'utilisateur de saisir le mot de passe qui permet de se connecter au serveur de la NASA, et qui lui indique si l'accès est autorisé ou pas.
Le mot de passe est "azerty".

Structure conditionnelle incomplète : _si ... alors ... _

La clause else est facultative. On obtient alors la structure suivante :
Bloc A Si condition vraie faire : Bloc B Bloc C Ainsi, si la condition est vraie, on effectuera les blocs A-B-C.
Si la condition n'est pas vraie, on effectuera les blocs A-C

Exercice 5 : Réécrire le programme qui affiche la plus grande des deux valeurs saisies par l'utilisateur, mais cette fois sans utiliser la clause else.

Combinées avec une boucle, les conditions permettent de "filtrer" des valeurs, comme dans l'exemple ci-dessous qui compte le nombre de fois où un dé a donné 6 sur 1000 lancers :

from random import *

compteur = 0
for i in range(1000):
    dé = randint(1,6)
    if dé == 6:
        compteur +=1
print("Le résultat 6 est sorti",compteur,"fois.")
Exercice 6 : Ecrire un programme qui simule 1000 lancers de deux dés, et qui affiche le nombre de fois où la somme 10 a été obtenue.

2- Les booléens

Comme on peut le voir en exécutant les trois cellules ci-dessous, des expressions comme 7>4 ou 8<2 ont une valeur d'un nouveau type appelé le type booléen.

Une variable booléenne ne peut prendre que deux valeurs : True ou False

True signifie "Vrai",
False signifie "Faux".

Le mot "booléen" provient de George Boole (1815-1864), un mathématicien et logicien anglais qui a créé l'algèbre binaire, aujourd'hui appelée algèbre booléenne. Cette algèbre booléenne permet de traduire des raisonements logiques par des calculs algébriques.

7 > 4
8 < 2
a = 7 > 4 
print(a)
print(type(a))
Exercice 7 : Déterminer pour chaque ligne le type et la valeur de chacune des variables ou expressions ci-dessous.
On suppose que les lignes sont exécutées l'une après l'autre.
x = 18 x > 7 x == 6 x > 7 x = 6 x > 7 x == 6
Exercice 8 : Qu'affiche le code suivant ?

b = 5 a = (b == 3) print(a)

Les booléens (ou variables booléennes) sont utilisés dans les conditions. En fait, l'expression qui suit le if doit toujours être une valeur ou une variable de type booléen :

majeur = True    # ou False
if majeur == True:
    print("Vous êtes majeur.")
else:
    print("Vous êtes mineur")

Syntaxe raccourcie des conditions
Dans le programme précédent, majeur == True est en fait un booléen qui vaut True ou False selon la valeur de la variable majeur.
Ainsi, les booléens permettent une syntaxe raccourcie et plus lisible lorsqu'on écrit des conditions :
Au lieu d'écrire if majeur == True:
on peut écrire : if majeur:
Il est préférable d'utiliser cette syntaxe raccourcie.

majeur = True    # ou False
if majeur:
    print("Vous êtes majeur.")
else:
    print("Vous êtes mineur")
Exercice 9 : Ecrire un programme qui :
  1. Demande à l'utilisateur sa taille en cm
  2. Crée une variable booléenne appelée "grand" dont la valeur dépend de la taille saisie
  3. Affiche un message différent selon que l'utilisateur est grand ou pas
    Par exemple : "Vous avez le droit (ou pas le droit) de monter dans ce manège."

3- Les conditions multiples

On a parfois besoin de tester plusieurs conditions successivement comme dans l'exemple suivant.

Le problème du pass sanitaire
On demande à une personne si elle est vaccinée et si elle a un test PCR négatif.
Si elle est vaccinée, elle peut entrer.
Sinon, elle ne peut entrer que si elle a un test PCR négatif.

vacciné = input("Etes-vous vacciné (O/N)?") == 'O'
testNégatif = input("Avez-vous un test PCR négatif (O/N)?") == 'O' 
          
if vacciné:
    print("Vous pouvez entrer...")
else:
    if testNégatif:
          print("Vous pouvez entrer!")
    else:
          print("Vous ne pouvez pas entrer!")

Le défaut de ce programme est qu'il est assez difficile à lire.
En Python, on dispose d'une syntaxe plus lègère qui permet de clarifier un peu le programme : on peut condenser le else if en une seule ligne elif.
Le programme ci-dessous fait exactement la même chose que le précédent mais nécessite une ligne de moins et fait moins appel à l'indentation dans les deux dernières lignes :

vacciné = input("Etes-vous vacciné (O/N)?") == 'O'
testNégatif = input("Avez-vous un test PCR négatif (O/N)?") == 'O' 
          
if vacciné:
    print("Vous pouvez entrer...")
elif testNégatif:
    print("Vous pouvez entrer!")
else:
    print("Vous ne pouvez pas entrer!")
Exercice 10 : Ecrire un programme qui demande à l'utilisateur sa moyenne du bac et qui lui indique sa mention.
Moyenne $[0;8[$ $[8;10[$ $[10;12[$ $[12;14[$ $[14;16[$ $[16;18[$ $[18;20]$
Mention Recalé Rattrapage Sans mention Assez bien Bien Très bien Félicitations
Exercice 11 : Ecrire un programme qui demande une année à l'utilisateur et indique s'il s'agit d'une année bissextile.
Une année est bissextile si elle est multiple de 4 mais pas multiple de 100, ou si elle est multiple de 400.
Tester ensuite votre programme avec les années 2021, 2020, 1900 et 2000. 
année = int(input("Veuillez saisir une année : "))

Les opérateurs booléens

On peut combiner plusieurs expressions booléennes avec les opérateurs and, or et not.
Dans le cadre des instructions conditionnelles, ces opérateurs permettent d'éviter de recourir à des conditions imbriquées.

Mot-cléEn FrançaisNomDescription
andetconjonctionc1 and c2 est vraie lorsque $c_1$ et $c_2$ sont toutes les deux vraies
oroudisjonctionc1 or c2 est vraie lorsqu'au moins une des deux conditions $c_1$ ou $c_2$ est vraie
notnonnégationnot c est vraie lorsque $c$ est fausse

Voici la table de vérité de ces trois opérateurs :

$c_1$$c_2$$c_1$ and $c_2$$c_1$ or $c_2$not $c_1$
VraiVraiVraiVraiFaux
VraiFauxFauxVraiFaux
FauxVraiFauxVraiVrai
FauxFauxFauxFauxVrai
Exercice 12 : Ecrire un programme qui simule 1000 lancers de deux dés, et qui affiche le nombre de fois où une somme comprise entre 4 et 8 inclus a été obtenue.

Remarque : Python autorise ici une syntaxe plus courte que ne permettent pas les autres langages. Pour tester si un nombre est compris entre 3 et 7, on peut écrire 3 < x < 7 au lieu de 3 < x and x < 7.

Nouvelle résolution du problème du pass sanitaire
Avec les booléens, on peut résoudre le problème du pass sanitaire de façon plus élégante, plus claire et plus courte qu'avec des condtions imbriquées :

vacciné = input("Etes-vous vacciné (O/N)?") == 'O'
testNégatif = input("Avez-vous un test PCR négatif (O/N)?") == 'O' 
          
if vacciné or testNégatif:
    print("Vous pouvez entrer!")
else:    
    print("Vous ne pouvez pas entrer!")
Exercice 13 : Reprendre le problème des années bissextiles (exercice 11) en utilisant des opérateurs booléens à la place des conditions imbriquées.
Une année est bissextile si elle est multiple de 4 mais pas multiple de 100, ou si elle est multiple de 400.
Tester ensuite votre programme avec les années 2021, 2020, 1900 et 2000. 
année = int(input("Veuillez saisir une année : "))

Merci, Thomas FOIRIEN !

Retour au sommaire

17 - if Correction

Conditions, tests et booléens (Correction)

  1. Les conditions
  2. Les booléens
  3. Les conditions multiples

1- Les conditions

Exercice 1 : Il faut mesurer au moins 1m30 pour pouvoir entrer dans un parc d'attractions.
Ecrire un programme qui demande à l'utilisateur sa taille en cm, et qui lui indique s'il peut ou non rentrer dans le parc. 
taille = int(input("Quelle est votre taille ? "))
if (taille >= 130):
    print("Bienvenue !")
else:
    print("Vous ne pouvez pas entrer, vous êtes trop petit!")
Quelle est votre taille ? 101
Vous ne pouvez pas entrer, vous êtes trop petit!
Exercice 2 : Ecrire un programme qui demande à l'utilisateur de saisir deux nombres, puis qui affiche le plus grand de ces deux nombres. 
a = int(input("Veuillez saisir le premier nombre : "))
b = int(input("Veuillez saisir le second nombre : "))
if a > b:
    print(a)
else:
    print(b)
Veuillez saisir le premier nombre : 8
Veuillez saisir le second nombre : 4
8
Exercice 3 : Ecrire un programme qui demande à l'utilisateur de saisir un nombre (positif ou négatif), puis qui affiche la valeur absolue de ce nombre. 
nombre = float(input("Veuillez saisir un nombre (positif ou négatif) : "))
if nombre >=0 :
    print(nombre)
else:
    print(-nombre)
Veuillez saisir un nombre (positif ou négatif) : -5
5.0
Exercice 4 : Ecrire un programme qui demande à l'utilisateur de saisir le mot de passe qui permet de se connecter au serveur de la NASA, et qui lui indique si l'accès est autorisé ou pas.
Le mot de passe est "azerty". 
motDePasse = "azerty"
motSaisi = input("Veuillez saisir le mot de passe : ")
if motSaisi == motDePasse:
    print("Accès autorisé")
else:
    print("Mot de passe incorrect - accès non autorisé")
Veuillez saisir le mot de passe : azerty
Accès autorisé

Structure conditionnelle incomplète : _si ... alors ... _

Exercice 5 : Réécrire le programme qui affiche la plus grande des deux valeurs saisies par l'utilisateur, mais cette fois sans utiliser la clause else. 
a = int(input("Veuillez saisir le premier nombre : "))
b = int(input("Veuillez saisir le second nombre : "))
maxi = a
if b > a:
    maxi = b
print(maxi)
Veuillez saisir le premier nombre : 5
Veuillez saisir le second nombre : 6
6
Exercice 6 : Ecrire un programme qui simule 1000 lancers de deux dés, et qui affiche le nombre de fois où la somme 10 a été obtenue. 
from random import *

compteur = 0
for i in range(1000):
    dé1 = randint(1,6)
    dé2 = randint(1,6)
    somme = dé1 + dé2
    if somme == 10:
        compteur = compteur + 1
print("La somme 10 a été obtenue",compteur,"fois")
La somme 10 a été obtenue 75 fois

2- Les booléens

Exercice 8 : Qu'affiche le code suivant ?

b = 5 a = (b == 3) print(a) 

b = 5
a = (b == 3)
print(a)
False
Exercice 9 : Ecrire un programme qui :
  1. Demande à l'utilisateur sa taille en cm
  2. Crée une variable booléenne appelée "grand" dont la valeur dépend de la taille saisie
  3. Affiche un message différent selon que l'utilisateur est grand ou pas
    Par exemple : "Vous avez le droit (ou pas le droit) de monter dans ce manège."
taille = int(input("Quelle est votre taille ? "))
grand = (taille >= 130)   # les parenthèses sont facultatives
if grand:
    print("Vous avez le droit de monter dans ce manège.")
else:
    print("Vous n'avez pas le droit de monter dans ce manège.")
Quelle est votre taille ? 135
Vous avez le droit de monter dans ce manège.

3- Les conditions multiples

Exercice 10 : Ecrire un programme qui demande à l'utilisateur sa moyenne du bac et qui lui indique sa mention.
Moyenne $[0;8[$ $[8;10[$ $[10;12[$ $[12;14[$ $[14;16[$ $[16;18[$ $[18;20]$
Mention Recalé Rattrapage Sans mention Assez bien Bien Très bien Félicitations 
moyenne = float(input("Quelle est votre moyenne ? "))
if moyenne < 8:
    print("Recalé")
elif moyenne < 10:
    print("Rattrapage")
elif moyenne < 12:
    print("Sans mention")
elif moyenne < 14:
    print("Assez bien")
elif moyenne < 16:
    print("Bien")
elif moyenne < 18:
    print("Très bien")
else:
    print("Félicitations")
Quelle est votre moyenne ? 13.2
Assez bien
Exercice 11 : Ecrire un programme qui demande une année à l'utilisateur et indique s'il s'agit d'une année bissextile.
Une année est bissextile si elle est multiple de 4 mais pas multiple de 100, ou si elle est multiple de 400.
Tester ensuite votre programme avec les années 2021, 2020, 1900 et 2000. 
année = int(input("Veuillez saisir une année : "))
# le secret est de commencer par les plus gros multiples
if année % 400 == 0:
    print("Bissextile")
elif année % 100 == 0:
    print("Non bissextile")
elif année % 4 == 0:
    print("Bissextile")
else:
    print("Non bissextile")       
Veuillez saisir une année : 2021
Non bissextile

Les opérateurs booléens

Exercice 12 : Ecrire un programme qui simule 1000 lancers de deux dés, et qui affiche le nombre de fois où une somme comprise entre 4 et 8 inclus a été obtenue. 
from random import *

compteur = 0
for i in range(1000):
    dé1 = randint(1,6)
    dé2 = randint(1,6)
    somme = dé1 + dé2
    if 4 <= somme and somme <= 8:
        compteur = compteur + 1
print("Une somme comprise entre 4 et 8 a été obtenue",compteur,"fois")
Une somme comprise entre 4 et 8 a été obtenue 646 fois

Remarque : Python autorise ici une syntaxe plus courte que ne permettent pas les autres langages. Pour tester si un nombre est compris entre 3 et 7, on peut écrire 3 < x < 7 au lieu de 3 < x and x < 7.

Exercice 13 : Reprendre le problème des années bissextiles (exercice 11) en utilisant des opérateurs booléens à la place des conditions imbriquées.
Une année est bissextile si elle est multiple de 4 mais pas multiple de 100, ou si elle est multiple de 400.
Tester ensuite votre programme avec les années 2021, 2020, 1900 et 2000. 
année = int(input("Veuillez saisir une année : "))
if (année % 4 == 0 and année % 100 != 0) or (année % 400 == 0):
    print("Bissextile")
else:
    print("Non bissextile")

Veuillez saisir une année : 2020
Bissextile

Retour au sommaire

18 - for

Python : Boucle for

  1. Boucle bornée
  2. Utilisation de la variable de boucle
  3. Notion d'accumulateur
  4. Dessiner avec Turtle

<p style="text-align:justify";>Dans un programme, on a souvent besoin de répéter plusieurs fois la même instruction (ou séquence d'instructions). On suppose dans ce chapitre que l'on sait à l'avance combien de fois on va devoir répéter la séquence d'instructions. La boucle for (ou boucle bornée) permet de répondre à ce besoin.
Remarque : Si on ne sait pas à l'avance combien de fois on va répéter la boucle (par exemple si on doit arrêter la boucle lorsqu'une certaine condition est réalisée), on utilisera la boucle while (tant que) qui sera vue dans le chapitre suivant.

1- Boucle bornée (boucle for)

Le programme ci-dessous est un exemple simple d'utilisation de la boucle for.
On répète ici 5 fois l'instruction print("Bonjour").
Le bloc d'instructions à répéter doit être indenté, c'est-à-dire décalé de quelques espaces vers la droite.
La variable i est l'indice de boucle (ou variable de boucle ou compteur de boucle).
On peut lui donner le nom que l'on veut.
Son utilisation sera vue dans la partie _2- Utilisation du compteur de boucle_.

for i in range(5):
    print("Bonjour")
Exercice 1 : La punition
Ecrire un programme qui affiche 100 fois "Je ne dois pas utiliser mon téléphone en classe."
Exercice 2 : Ecrire un programme qui demande à l'utilisateur quel message il souhaite afficher, puis qui affiche ce message 10 fois.
Exercice 3 : Ecrire un programme qui demande à l'utilisateur de saisir un nombre entier, puis qui affiche le nombre de fois correspondant le message "Coucou!".
Exercice 4 : Compléter le programme ci-dessous pour qu'il calcule et affiche le produit 42x37 en n'effectuant que des additions. 
produit = 0
for i in range(...)
    ...
print(produit)

On peut effectuer plusieurs instructions dans une boucle :

for compteur in range(4):
    print("Bonjour")
    print("###############")
print("Au revoir")
Exercice 5 : Quelle est la valeur des variables a et b à la fin du programme ci-dessous ? 
a :          b : 
a=0
b=6
for i in range(10):
    a+=1
    b+=7

Boucles imbriquées

<p style="text-align:justify";>On a parfois besoin d'insérer une boucle à l'intérieur d'une autre boucle, par exemple lorsqu'on souhaite parcourir successivement tous les pixels d'une image. On parcourt l'image ligne par ligne, et on parcourt chaque ligne colonne par colonne.
La structure est la suivante :

for i ...
    for j ...
        instructions
        instructions
Exercice 6 : 1) Ecrire un programme qui affiche un rectangle de 5 lignes et 10 colonnes avec le caractère # comme ci-dessous :
##########
##########
##########
##########
##########
2) Améliorer ce programme pour qu'il demande d'abord à l'utilisateur de saisir la largeur et la hauteur du rectangle.
On peut aussi lui demander avec quel caractère il souhaite remplir le rectangle.
Exercice 7 : Quelle est la valeur de la variable a à la fin du programme ci-dessous ? 
a : 
a=0
for i in range(6):
    for j in range(7):
        a+=1

2- Utilisation de la variable de boucle

Comme le montre l'exemple suivant, la variable de boucle (i dans l'exemple) est une variable ordinaire qui a initialement la valeur 0 et qui est incrémentée de 1 à chaque tour de la boucle. On peut choisir n'importe quel nombre pour cette variable. Des noms tels que i, j, k, m, n, index ou compteur sont fréquemment utilisés.
Attention à la dernière valeur qui est 9 et non 10, car on a commencé à 0! Cependant, le nombre qui figure en paramètre de la fonction range() (ici 10) correspond bien au nombre de tours de boucle.
La variable de boucle est aussi appelée "compteur de boucle". Elle permet de savoir combien de tours de boucle ont déjà été effectués.

for i in range(10):
    print(i)
print(i)

Remarque : Cet exemple montre aussi que la variable de boucle existe toujours après l'exécution de la boucle.
Il est cependant déconseillé d'utiliser cette variable en dehors de la boucle.
Il est également déconseillé de modifier le contenu de la variable de boucle à l'intérieur de la boucle.

Exercice 8 : Ecrire un programme qui affiche tous les entiers pairs de 0 à 100 inclus, sans utiliser d'autre variable que la variable de boucle.
Exercice 9 : Ecrire un programme qui effectue un compte à rebours à partir d'une valeur entière saisie par l'utilisateur, sans utiliser d'autre variable que la variable de boucle.
Exercice 10 : Ecrire un programme qui dessine un triangle comme ci-dessous avec une hauteur saisie par l'utilisateur.
*
**
***
**** 
hauteur=int(input("Veuillez saisir la hauteur du triangle : "))

Les secrets de la fonction range()

Secret n°1 "range" signifie "intervalle" en anglais.
range(n) renvoie en réalité la liste de tous les entiers de 0 inclus à n exclu.
Vous pouvez tester cela en tapant list(range(8)).
"for i in range(8) :" signifie donc littéralement :
"pour i prenant successivement toutes les valeurs de 0 à 7, faire :"
Secret n°2 La fonction range() peut prendre deux paramètres en entrée.
Si a et b sont deux entiers, range(a,b) renvoie la liste de tous entiers compris entre a inclus et b exclu.
Secret n°3 La fonction range() peut même prendre trois paramètres en entrée.
Si a, b et p sont trois entiers, range(a,b,c) renvoie la liste de tous entiers compris entre a inclus et b exclu avec un pas p.
Si le pas p est négatif, les nombres de la liste seront données dans l'ordre décroissant.
Exercice 11 : Tester les versions avec deux paramètres et trois paramètres (avec un pas positif et avec un pas négatif) de la fonction range().

3- Notion d'accumulateur

Le compteur de boucle permet de mettre en place un accumulateur, c'est-à-dire une variable qui est utilisée pour stocker les différents résultats successifs d'un calcul qui avance progressivement à chaque tour de boucle. On économise ainsi de la mémoire : on ne garde en mémoire par exemple que la somme des valeurs déjà rencontrées ou le dernier état, et non tous les états intermédiaires.
La variable qui sert d'accumulateur doit être initialisée avant la boucle.

Exemple : calcul de la somme des entiers de 1 à 100

somme = 0 # La variable somme joue le rôle de l'accumulateur
for i in range(101):
    somme = somme + i   # à chaque tour de boucle, on met à jour la valeur de l'accumulateur en lui ajoutant i
print(somme)      # On affiche la valeur finale de l'accumulateur

Remarque : il existe une formule qui permet de calculer cette somme sans effectuer toutes les additions, qui sera vue en cours de Spécialité Maths : $1+2+3+...+n = \frac{n(n+1)}{2}$.

Exercice 12 : Ecrire un programme qui demande 5 notes à l'utilisateur et qui affiche la moyenne de ces notes.
Exercice 13 : Ecrire un programme simule le lancer de 1000 dés et qui affiche la moyenne des résultats obtenus.
Exercice 14 : Ecrire un programme qui demande à l'utilisateur un entier a et un entier n et qui calcule $a^n$ à l'aide d'une boucle for (on verra plus tard un algorithme plus rapide que celui-ci).
Remarque : il est interdit d'utiliser ** ici!
Exercice 15 : Ecrire un programme qui demande de saisir un entier positif n et qui calcule la factorielle de n.
La factorielle de n, notée $n!$ est définie par $n! = 1\times 2\times 3\times...\times n$ .
On a par exemple $3! = 6$.
Exercice 16 : Quel est le rôle de l'algorithme ci-dessous ?
a=float(input("Veuillez saisir un nombre positif (pas nécessairement entier) : "))
r=1
for i in range(20):
   r=r/2+a/r/2
print(r)

4- Dessiner avec Turtle

La bibliothèque turtle permet de dessiner à l'écran.
Le petit programme commenté ci-dessous permet d'obtenir un tracé intéressant :

from turtle import *      # On importe la bibliothèque turtle

speed(10)                 # On règle la vitesse du tracé (un entier compris entre 1 et 10)
color('red', 'yellow')    # On fixe la couleur du tracé à 'rouge' et la couleur de rempissage à 'jaune'
begin_fill()
for i in range(36):
    forward(200)          # La tortue avance de 200 pixels 
    left(170)             # La tortue tourne vers la gauche de 170°
end_fill()
done()                    # Il faut terminer par done() pour lancer l'exécution du tracé

Voici quelques fonctionnalités de turtle :

FonctionDescription
forward(x)Déplace la tortue de x pixels en marche avant.
backward(x)Déplace la tortue de x pixels en marche arrière.
left(x)Fait pivoter la tortue d'un angle de x degrés vers la gauche.
right(x)Fait pivoter la tortue d'un angle de x degrés vers la droite.
goto(x,y)Déplace la tortue au point de corrdonnées (x,y). Attention, l'axe des y est orienté vers le haut de l'écran comme en mathématiques!
penup()Lève le crayon (la tortue arrêtera de tracer).
pendown()Abaisse le crayon. La tortue se remettra à tracer.
hideturtle()Cache la tortue.
showturtle()Fait réapparaitre la tortue.
speed(n)Règle la vitesse du tracé. n est un entier compris entre 0 et 10. 1 correspond à une vitesse lente, 10 correspond à une vitesse rapide. 0 permet d'obtenir un tracé instantané.
done()Lance l'exécution du tracé.
circle(r)Trace un cercle de rayon r.
On peut ajouter une deuxième paramètre facultatif a si on souhaite tracer seulement tracer un arc de cercle d'angle a.
color(couleur1,couleur2)Définir la couleur du tracé (couleur1) et la couleur de remplissage (couleur2).
width(n)Règle l'épaisseur du trait à n pixels.
Exercice 17 : Ecrire un programme qui utilise une boucle for pour tracer un carré de côté 100 pixels, avec un contour bleu et colorié en vert.
Exercice 18 : Ecrire un programme qui trace 10 cercles dont les rayons sont 10, 20, 30, ..., 100.
Choisir une couleur de tracé et une couleur de remplissage.
Exercice 19 : Dessiner le drapeau de la France avec Turtle.

Merci, Thomas FOIRIEN !

Retour au sommaire

19 - for Correction

Python : Boucle for (correction)

  1. Boucle bornée
  2. Utilisation de la variable de boucle
  3. Notion d'accumulateur
  4. Dessiner avec Turtle

1- Boucle bornée (boucle for)

for i in range(5):
    print("Bonjour")
Exercice 1 : La punition
Ecrire un programme qui affiche 100 fois "Je ne dois pas utiliser mon téléphone en classe." 
for i in range(100):
    print("Je ne dois pas utiliser mon téléphone en classe.")
Exercice 2 : Ecrire un programme qui demande à l'utilisateur quel message il souhaite afficher, puis qui affiche ce message 10 fois. 
message = input("quel message souhaitez-vous afficher ? ")
for i in range(10):
    print(message)
Exercice 3 : Ecrire un programme qui demande à l'utilisateur de saisir un nombre entier, puis qui affiche le nombre de fois correspondant le message "Coucou!". 
nb = int(input("Combien de fois souhaitez-vous afficher le message ? "))
for i in range(nb):
    print("Coucou!")
Exercice 4 : Compléter le programme ci-dessous pour qu'il calcule et affiche le produit 42x37 en n'effectuant que des additions. 
produit = 0
for i in range(42):
    produit = produit + 37     # ou produit += 37
print(produit)

On peut effectuer plusieurs instructions dans une boucle :

for compteur in range(4):
    print("Bonjour")
    print("###############")
print("Au revoir")
Exercice 5 : Quelle est la valeur des variables a et b à la fin du programme ci-dessous ? 
a : 10         b : 76
a=0
b=6
for i in range(10):
    a+=1
    b+=7

Boucles imbriquées

Exercice 6 : 1) Ecrire un programme qui affiche un rectangle de 5 lignes et 10 colonnes avec le caractère # comme ci-dessous :
##########
##########
##########
##########
##########
2) Améliorer ce programme pour qu'il demande d'abord à l'utilisateur de saisir la largeur et la hauteur du rectangle.
On peut aussi lui demander avec quel caractère il souhaite remplir le rectangle.
# 1ère question
for ligne in range(5):
    texte = ""
    for colonne in range(10):
        texte = texte + "#"    # ou texte += "#"
    print(texte)
# 2ème question
largeur = int(input("Veuillez saisir la largeur du rectangle : "))
hauteur = int(input("Veuillez saisir la hauteur du rectangle : "))
caractère = input("Veuillez saisir le caractère de remplissage : ")
for ligne in range(hauteur):
    texte = ""
    for colonne in range(largeur):
        texte = texte + caractère    # ou texte += caractère
    print(texte)
Exercice 7 : Quelle est la valeur de la variable a à la fin du programme ci-dessous ? 
a : 42
a=0
for i in range(6):
    for j in range(7):
        a+=1

2- Utilisation de la variable de boucle

for i in range(10):
    print(i)
print(i)
Exercice 8 : Ecrire un programme qui affiche tous les entiers pairs de 0 à 100 inclus, sans utiliser d'autre variable que la variable de boucle. 
for i in range(51):   # rappel : i prend toutes les valeurs de 0 et 50 inclus
    print(2*i)
Exercice 9 : Ecrire un programme qui effectue un compte à rebours à partir d'une valeur entière saisie par l'utilisateur, sans utiliser d'autre variable que la variable de boucle. 
nombreDépart = int(input("Saisissez le nombre de départ : "))
for i in range(nombreDépart+1):
    print(nombreDépart-i)
Exercice 10 : Ecrire un programme qui dessine un triangle comme ci-dessous avec une hauteur saisie par l'utilisateur.
*
**
***
**** 
hauteur=int(input("Veuillez saisir la hauteur du triangle : "))
for ligne in range(hauteur):
    texte = ""
    for colonne in range(ligne+1):
        texte = texte + "*"
    print(texte)

Les secrets de la fonction range()

Exercice 11 : Tester les versions avec deux paramètres et trois paramètres (avec un pas positif et avec un pas négatif) de la fonction range().
list(range(5,9))
list(range(10,22,3))
list(range(22,10,-3))

3- Notion d'accumulateur

Exercice 12 : Ecrire un programme qui demande 5 notes à l'utilisateur et qui affiche la moyenne de ces notes.
somme = 0
for i in range(5):
    message = "Saisissez la note n°"+str(i+1)+" : "
    note = float(input(message))
    somme = somme + note   # ou somme += note
moyenne = somme / 5
print("La moyenne des notes est",moyenne)
Exercice 13 : Ecrire un programme simule le lancer de 1000 dés et qui affiche la moyenne des résultats obtenus.
from random import *

somme = 0
for i in range(1000):
    dé = randint(1,6)
    somme = somme + dé
moyenne = somme / 1000
print("La moyenne des 1000 lancers est",moyenne)
Exercice 14 : Ecrire un programme qui demande à l'utilisateur un entier a et un entier n et qui calcule $a^n$ à l'aide d'une boucle for (on verra plus tard un algorithme plus rapide que celui-ci).
Remarque : il est interdit d'utiliser ** ici! 
a = int(input("Veuillez saisir la valeurs de a (la base) : "))
n = int(input("Veuillez saisir la valeur de n (l'exponsant) : "))
puissance = 1
for i in range(n):
    puissance = puissance * a
print(a,"puissance",n,"est égal à",puissance)
Exercice 15 : Ecrire un programme qui demande de saisir un entier positif n et qui calcule la factorielle de n.
La factorielle de n, notée $n!$ est définie par $n! = 1\times 2\times 3\times...\times n$ .
On a par exemple $3! = 6$.
n = int(input("Veuillez saisir un entier positif : "))
factorielle = 1
for i in range(1,n+1):
    factorielle = factorielle * i
print("La factorielle de ",n,"est",factorielle)
Exercice 16 : Quel est le rôle de l'algorithme ci-dessous ?
a=float(input("Veuillez saisir un nombre positif (pas nécessairement entier) : "))
r=1
for i in range(20):
   r=r/2+a/r/2
print(r)

Ce programme calcule (une valeur approchée de) la racine carrée du nombre saisi par la méthode de Héron (ou méthode babylonienne) connue depuis plus de 2000 ans.

4- Dessiner avec Turtle

Exercice 17 : Ecrire un programme qui utilise une boucle for pour tracer un carré de côté 100 pixels, avec un contour bleu et colorié en vert.
from turtle import *

color('blue', 'green') 
begin_fill()
for i in range(4):
    forward(100)
    left(90)
end_fill()
done()
Exercice 18 : Ecrire un programme qui trace 10 cercles dont les rayons sont 10, 20, 30, ..., 100.
Choisir une couleur de tracé et une couleur de remplissage.
from turtle import *

color('red', 'pink') 
speed(10)
begin_fill()
for i in range(1,11):
    circle(10*i)    
end_fill()
done()
Exercice 19 : Dessiner le drapeau de la France avec Turtle.
from turtle import *

color('black', 'blue') 
begin_fill()
for i in range(2):
    forward(100)
    left(90)
    forward(200)
    left(90)
end_fill()
forward(100)

color('black', 'white') 
begin_fill()
for i in range(2):
    forward(100)
    left(90)
    forward(200)
    left(90)
end_fill()
forward(100)

color('black', 'red') 
begin_fill()
for i in range(2):
    forward(100)
    left(90)
    forward(200)
    left(90)
end_fill()
forward(100)

done()

Retour au sommaire

20 - while

Boucle while

  1. La boucle while
  2. L'instruction pass
  3. Sortie anticipée d'une boucle : l'instruction break
  4. Retour anticipé au début de la boucle : l'instruction continue

Seule la partie 1. La boucle while est fondamentale dans ce chapitre. Les trois autres parties sont plus anecdotiques et peuvent être omises pour une première découverte de la boucle while.

1- La boucle while

La boucle for a l'avantage d'être simple à utiliser, mais elle nécessite de connaître à l'avance (avant d'entrer dans la boucle) le nombre de tours de boucles qui vont être effectués. Dans certaines situations, on souhaiterait demander au programme de sortir de la boucle lorsqu'une certaine condition est réalisée, par exemple lorsqu'une valeur dépasse un certain seuil, ou lorsque l'utilisateur a saisi le bon mot de passe ou cliqué sur un bouton. La boucle while permet de répondre à ce besoin.

Syntaxe de la boucle while

while condition: bloc d'instructions A bloc d'instructions B

Tant que la condition est vraie, le bloc d'instructions A est exécuté, généralement plusieurs fois. Les instructions du bloc A agissent sur la condition pour la rendre fausse au bout d'un certain nombre de tours. Alors le programme sort de la boucle et se poursuit avec l'exécution du bloc B.

Remarques :

  • La boucle while est parfois appelée "boucle non bornée" (nombre de tours non connu à l'avance, pouvant éventuellement dépasser n'importe quelle valeur) par opposition à la boucle for qui est appelée "boucle bornée" (le nombre de tours de boucle ne dépassera pas une valeur fixée à l'avance).
  • Il est possible que la boucle ne soit jamais exécutée, si la condition est initialement fausse.
  • Il est possible que le programme boucle indéfiniment et ne s'arrête jamais, lorsque la condition est toujours vraie. On parle alors de boucle infinie.
    Dans Capytale, il est recommandé de sauvegarder son travail régulièrement car il n'est pas toujours possible d'interrompre le programme en cas de boucle infinie.
  • On peut se passer complètement des boucles for et les remplacer par des boucles while comme le montrent les deux programmes équivalents ci-dessous : 
for i in range(5):
    print("Coucou")
i = 0
while i < 5:
    print("Coucou")
    i = i + 1

Comme on le voit, l'utilisation de la boucle while nécessite d'écrire deux lignes de plus car il faut gérer soi-même la variable de boucle (son initialisation et son incrémentation).
Lorsque cela est possible (c'est-à-dire si le nombre de tours est connu à l'avance), il est donc préférable d'utiliser une boucle for pour améliorer la lisibilité du code.

Exercice 1 : Réécrire le programme ci-dessous avec une boucle while.
somme = 0 for i in range(10): somme = somme + i print(somme)

Exemples d'utilisation de la boucle while

Dépassement d'un seuil

La boucle while est souvent utilisée (notamment en mathématiques) pour déterminer le rang à partir duquel un certain seuil sera dépassé ou atteint.
Voci un premier exemple :
On dispose d'un capital de 1 000€, et chaque année, on perçoit 5% d'intérêts composés et on ajoute 500€ sur le compte.
Au bout de combien d'années la valeur du compte dépassera-t-elle les 10 000€?

from tutor import tutor

def nombreAnnées(capital):
    année = 0
    while capital <= 10000:
        capital = capital * 1.05 + 500 
        année += 1
    return année

nombreAnnées(1000)

tutor()
Exercice 2 : La population d'un village de 1000 habitants diminue chaque année de 1%.
Ecrire un programme qui calcule le nombre d'années au bout duquel la population de ce village aura diminué de moitié.
Exercice 3 : Ecrire une fonction division(a,b) qui renvoie le quotient de la division euclidienne de a par b, par la méthode des soustractions successives. a et b sont ici des entiers positifs, avec b non nul.
Il est évidemment interdit ici d'utiliser l'opérateur //!
Question subsidiaire : !!! Avant de répondre à cette question, sauvegardez votre travail !!!
Pourquoi le programme ne fonctionne-t-il pas si on essaie de diviser par 0 (b = 0) ?
def division(a,b):
    assert type(a) == type(1), "Le type du premier paramètre a doit être entier!"
    assert a>=0, "Le premier paramètre a doit être positif ou nul!"
    assert type(b) == type(1), "Le type du second paramètre b doit être entier!"
    assert b>0, "Le second paramètre b ne doit pas être nul et doit être positif!"    
    # code de la fonction division à compléter ici
    ...
    
# Quelques tests
assert division(19,3) == 6
assert division(18,3) == 6
assert division(0,5) == 0

Attente de la réalisation d'un événement

Plus généralement, on utilise la boucle while lorsqu'on souhaite attendre qu'une certain événement soit réalisé avant de continuer (saisie du bon mot de passe, déplacement de la souris, clic sur un bouton, détection d'un son dans le micro, etc...)
Dans l'exemple ci-dessous, on attend que l'utilisateur saisisse la valeur 0 pour sortir de la boucle.

somme = 0
nombre = 1   # ici à la place de 1, on aurait pu mettre n'importe quel nombre (sauf 0)
while nombre != 0:
    nombre = int(input("Veuillez saisir le nombre de ventes réalisées (0 pour arrêter) : "))
    somme += nombre
print("La somme de vos ventes est",somme)
Exercice 4 : Ecrire un programme qui attend que l'utilisateur ait saisi le bon mot de passe avant de lui donner l'accès.
Le mot de passe est "PIZZA".
Exercice 5 : Le jeu "Plus ou Moins"
Programmer le jeu suivant :
L'ordinateur choisi un nombre entier aléatoire entre 1 et 100.
Le joueur doit deviner ce nombre-mystère en faisant plusieurs propositions successives. Après chaque proposition, le programme indique au joueur si son nombre est trop petit ou trop grand. Le jeu s'arrête lorsque le nombre-mystère a été trouvé.
Vous pouvez ajouter un compteur qui indique le nombre d'essais du joueur.
Question subsidiaire : Quel nombre minimal d'essais faut-il faire pour être sûr de deviner le nombre?
Exercice 6 : Ecrire un programme qui demande à l'utilisateur de saisir un nombre entier strictement positif et qui affiche le nombre de chiffres de ce nombre.
Votre programme doit utiliser une boucle while.
Exercice 7 : !!! Avant de faire cet exercice, sauvegardez votre travail !!!
Le programme suivant effectue un compte à rebours de 2 en 2 à partir de 99.
Ce programme termine-t-il ? Si non, le corriger. 
# Compte à rebours
compteur = 99
while compteur != 0:        
    print(compteur) 
    compteur -= 2

2- L'instruction pass

Le code ci-dessous provoque une erreur car le corps de la boucle est vide :

while 2 < 1:

Dans certains cas un peu particuliers, on peut avoir besoin de laisser temporairement vide le corps d'une boucle (for ou while) ou d'une fonction. Par exemple on peut souhaiter compléter plus tard le corps d'une fonction et le laisser vide sans que cela ne provoque une erreur. Pour cela, il existe en Python une instruction pass dont le rôle est ... de ne rien faire.
Ainsi, le code ci-dessous ne provoque plus d'erreur :

while 2 < 1:
    pass
Exercice 8 : Compléter le code de la fonction ci-dessous : 
"""Cette fonction devra afficher True si n > 5 et False sinon """
def grand(n):
    pass

3- Sortie anticipée d'une boucle : l'instruction break

On a parfois besoin de sortir plus tôt que prévu d'une boucle en cas d'événement exceptionnel (par exemple si une erreur se produit). L'instruction break (qui doit être située dans le corps d'une boucle) permet de mettre fin immédiatement à la boucle. Le programme se poursuivra en exécutant les instructions situées juste après la boucle.

somme = 0
for i in range(5):
    âge = int(input("Veuillez saisir l'âge du passager n°"+str(i+1)+" : "))
    if âge < 12:
        print("Désolé, nous n'acceptons pas les enfants!")
        break

Dans certaines situations, une boucle infinie combinée avec une instruction break peut permettre d'obtenir un programme un peu plus simple, comme dans le problème du mot de passe (exercice 4) qui est repris dans l'exercice suivant :

Exercice 9 : Réécrire le programme de l'exercice 4 de façon plus lisible en utilisant l'opérateur == plutôt que !=, une boucle infinie et une instruction break pour sortir de la boucle.
Ce programme attend que l'utilisateur ait saisi le bon mot de passe avant de lui donner l'accès. Le mot de passe est "PIZZA".
Exercice 10 : Quelle est la valeur de la variable somme après exécution du programme ci-dessous ? somme = 0 for i in range(10): somme = somme + i if i == 5: break
Exercice 11 : Ecrire un programme qui affiche la liste de tous les nombres premiers compris entre 1 et 100.

4- Retour anticipé au début de la boucle : l'instruction continue

Dans une boucle (for ou while), l'instruction continue demande au programme de revenir immédiatement au début de la boucle pour effectuer le tour suivant, sans terminer le tour de boucle qui était en cours d'exécution.
Cette instruction permet dans certains cas d'améliorer un peu la lisibilité du programme.

Exercice 12 : Un hôtel comporte 19 chambres numérotées de 1 à 20, mais la chambre n°13 n'existe pas.
Le programme ci-dessous affiche la liste de tous les numéros de chambres de l'hôtel.
Le petit défaut (qui concerne seulement la lisibilité) de ce programme est que l'instruction print(i) est reléguée au 2ème niveau d'indentation alors qu'il s'agit de l'instruction qui est effectuée dans les cas ordinaires (et non dans le cas exceptionnel de la chambre n°13).
Réécrire une version plus lisible de ce programme, dans laquelle l'instruction print(i) sera écrite au 1er niveau d'indentation. 
for i in range(1,21):
    if i != 13:
        print(i)
Exercice 13 : Cet exercice n'existe pas.
Exercice 14 : Quelle est la valeur de la variable somme après exécution du programme ci-dessous ? somme = 0 for i in range(10): if i == 5: continue if i == 8: break somme = somme + i

Merci, Thomas FOIRIEN !

Retour au sommaire

21 - while Correction

Boucle while (Correction)

  1. La boucle while
  2. L'instruction pass
  3. Sortie anticipée d'une boucle : l'instruction break
  4. Retour anticipé au début de la boucle : l'instruction continue

1- La boucle while

Exercice 1 : Réécrire le programme ci-dessous avec une boucle while.
somme = 0 for i in range(10): somme = somme + i print(somme) 
somme = 0
i = 0
while i < 10:
    somme = somme + i
    i = i + 1
print(somme)
45

Exemples d'utilisation de la boucle while

Exercice 2 : La population d'un village de 1000 habitants diminue chaque année de 1%.
Ecrire un programme qui calcule le nombre d'années au bout duquel la population de ce village aura diminué de moitié. 
population = 1000
années = 0
while population > 500:
    années = années + 1
    population = population * 0.99  # coeffcient multiplcateur : 1 - 1/100 = 0.99
print(années)        
69
Exercice 3 : Ecrire une fonction division(a,b) qui renvoie le quotient de la division euclidienne de a par b, par la méthode des soustractions successives. a et b sont ici des entiers positifs, avec b non nul.
Il est évidemment interdit ici d'utiliser l'opérateur //!
Question subsidiaire : !!! Avant de répondre à cette question, sauvegardez votre travail !!!
Pourquoi le programme ne fonctionne-t-il pas si on essaie de diviser par 0 (b = 0) ?
def division(a,b):
    assert type(a) == type(1), "Le type du premier paramètre a doit être entier!"
    assert a>=0, "Le premier paramètre a doit être positif ou nul!"
    assert type(b) == type(1), "Le type du second paramètre b doit être entier!"
    assert b>0, "Le second paramètre b ne doit pas être nul et doit être positif!"    
    # code de la fonction division à compléter ici
    quotient = 0
    while a >= b:
        a = a - b
        quotient = quotient + 1
    return quotient        
    
# Quelques tests
assert division(19,3) == 6
assert division(18,3) == 6
assert division(0,5) == 0

# Réponse à la question subsidiaire :
# Si on essaie de diviser par 0, on aura une boucle infinie!
# Ceci est une manière d'expliquer pourquoi on ne peut pas diviser par 0 en maths.

Attente de la réalisation d'un événement

Exercice 4 : Ecrire un programme qui attend que l'utilisateur ait saisi le bon mot de passe avant de lui donner l'accès.
Le mot de passe est "PIZZA". 
motDePasse = "PIZZA"
motSaisi = ""
while motSaisi != motDePasse:
    motSaisi = input("Veuillez saisir le mot de passe : ")
print("Accès autorisé")    
Veuillez saisir le mot de passe : AZERTY
Veuillez saisir le mot de passe : PIERROT123
Veuillez saisir le mot de passe : PIZZA
Accès autorisé
Exercice 5 : Le jeu "Plus ou Moins"
Programmer le jeu suivant :
L'ordinateur choisi un nombre entier aléatoire entre 1 et 100.
Le joueur doit deviner ce nombre-mystère en faisant plusieurs propositions successives. Après chaque proposition, le programme indique au joueur si son nombre est trop petit ou trop grand. Le jeu s'arrête lorsque le nombre-mystère a été trouvé.
Vous pouvez ajouter un compteur qui indique le nombre d'essais du joueur.
Question subsidiaire : Quel nombre minimal d'essais faut-il faire pour être sûr de deviner le nombre?
import random

nombreMystère = random.randint(1,100)
nombreProposé = -1
while nombreProposé != nombreMystère:
    nombreProposé = int(input("Quel nombre proposez-vous ? "))
    if nombreProposé > nombreMystère:
        print("Trop grand")
    elif nombreProposé < nombreMystère:
        print("Trop petit")    
print("Bravo vous avez trouvé le nombre mystère !")
Quel nombre proposez-vous ? 50
Trop petit
Quel nombre proposez-vous ? 75
Trop petit
Quel nombre proposez-vous ? 87
Trop grand
Quel nombre proposez-vous ? 81
Trop grand
Quel nombre proposez-vous ? 78
Bravo vous avez trouvé le nombre mystère !

# Version avec compteur
import random

nombreMystère = random.randint(1,100)
nombreProposé = -1
compteur = 0
while nombreProposé != nombreMystère:
    nombreProposé = int(input("Quel nombre proposez-vous ? "))
    compteur = compteur + 1
    if nombreProposé > nombreMystère:
        print("Trop grand")
    elif nombreProposé < nombreMystère:
        print("Trop petit")    
print("Bravo vous avez trouvé le nombre mystère en",compteur,"coups !")
Quel nombre proposez-vous ? 50
Trop grand
Quel nombre proposez-vous ? 25
Trop grand
Quel nombre proposez-vous ? 12
Trop grand
Quel nombre proposez-vous ? 6
Trop grand
Quel nombre proposez-vous ? 3
Trop petit
Quel nombre proposez-vous ? 4
Bravo vous avez trouvé le nombre mystère en 6 coups !

Réponse à la question subsidiaire : on est sûr de trouver le nombre mystère en 7 coups au plus, en utilisant la stratégie de la dichotomie, qui consiste à proposer à chaque fois le nombre situé au milieu de l'intervalle des nombres encore possibles.
Cette question est liée à la recherche dichotomique qui sera étudiée plus tard.

Exercice 6 : Ecrire un programme qui demande à l'utilisateur de saisir un nombre entier strictement positif et qui affiche le nombre de chiffres de ce nombre.
Votre programme doit utiliser une boucle while. 
nombre = int(input("Veuillez saisir un entier strictement positif : "))
nbChiffres = 1
while nombre >= 10:
    nombre = nombre // 10
    nbChiffres = nbChiffres + 1
print(nbChiffres)
Veuillez saisir un entier strictement positif : 999
3

#Autre méthode (en trichant)
nombre = input("Veuillez saisir un entier strictement positif : ")
print(len(nombre))
Veuillez saisir un entier strictement positif : 1234
4
Exercice 7 : !!! Avant de faire cet exercice, sauvegardez votre travail !!!
Le programme suivant effectue un compte à rebours de 2 en 2 à partir de 99.
Ce programme termine-t-il ? Si non, le corriger. 
# Compte à rebours
compteur = 99
while compteur != 0:        
    print(compteur) 
    compteur -= 2       
# Le programme précédent ne se termine jamais car il y a une boucle infinie.
# En effet, le compteur diminue de 2 en 2 en partant de 99, donc il sera toujours impair et ne sera jamais égal à 0
# Version corrigé du programme :

# Compte à rebours
compteur = 99
while compteur >= 0:       # il fallait remplacer != par >= 
    print(compteur) 
    compteur -= 2     
99
97
95
93
91
89
87
85
83
81
79
77
75
73
71
69
67
65
63
61
59
57
55
53
51
49
47
45
43
41
39
37
35
33
31
29
27
25
23
21
19
17
15
13
11
9
7
5
3
1

2- L'instruction pass

Exercice 8 : Compléter le code de la fonction ci-dessous : 
"""Cette fonction devra afficher True si n > 5 et False sinon """
def grand(n):
    return n > 5

print(grand(10))
print(grand(4))
True
False

3- Sortie anticipée d'une boucle : l'instruction break

Exercice 9 : Réécrire le programme de l'exercice 4 de façon plus lisible en utilisant l'opérateur == plutôt que !=, une boucle infinie et une instruction break pour sortir de la boucle.
Ce programme attend que l'utilisateur ait saisi le bon mot de passe avant de lui donner l'accès. Le mot de passe est "PIZZA".
motDePasse = "PIZZA"
while True:
    if input("Veuillez saisir le mot de passe : ") == motDePasse:
        print("Accès autorisé")
        break
Veuillez saisir le mot de passe : TEST
Veuillez saisir le mot de passe : PIZZA
Accès autorisé
Exercice 10 : Quelle est la valeur de la variable somme après exécution du programme ci-dessous ? somme = 0 for i in range(10): somme = somme + i if i == 5: break 
somme = 0
for i in range(10):
    somme = somme + i
    if i == 5:
        break
    print("i : ",i,"somme : ",somme)
print("i : ",i,"somme : ",somme)    
# Réponse : somme vaut 15
i :  0 somme :  0
i :  1 somme :  1
i :  2 somme :  3
i :  3 somme :  6
i :  4 somme :  10
i :  5 somme :  15
Exercice 11 : Ecrire un programme qui affiche la liste de tous les nombres premiers compris entre 1 et 100.
print(2,end='-')
for n in range(3,101):
    for i in range(2,n):
        if n % i == 0: 
            break
        if i == n-1: 
            print(n,end='-')
2-3-5-7-11-13-17-19-23-29-31-37-41-43-47-53-59-61-67-71-73-79-83-89-97-

4- Retour anticipé au début de la boucle : l'instruction continue

Exercice 12 : Un hôtel comporte 19 chambres numérotées de 1 à 20, mais la chambre n°13 n'existe pas.
Le programme ci-dessous affiche la liste de tous les numéros de chambres de l'hôtel.
Le petit défaut (qui concerne seulement la lisibilité) de ce programme est que l'instruction print(i) est reléguée au 2ème niveau d'indentation alors qu'il s'agit de l'instruction qui est effectuée dans les cas ordinaires (et non dans le cas exceptionnel de la chambre n°13).
Réécrire une version plus lisible de ce programme, dans laquelle l'instruction print(i) sera écrite au 1er niveau d'indentation. 
for i in range(1,21):
    if i != 13:
        print(i)
1
2
3
4
5
6
7
8
9
10
11
12
14
15
16
17
18
19
20

for i in range(1,21):
    if i == 13:
        continue
    print(i)
1
2
3
4
5
6
7
8
9
10
11
12
14
15
16
17
18
19
20
Exercice 13 : Cet exercice n'existe pas.
Exercice 14 : Quelle est la valeur de la variable somme après exécution du programme ci-dessous ? somme = 0 for i in range(10): if i == 5: continue if i == 8: break somme = somme + i 
somme = 0
for i in range(10):    
    if i == 5:
        continue
    if i == 8:
        break
    somme = somme + i
    print("i : ",i,"somme : ",somme)
print("i : ",i,"somme : ",somme) 
# Réponse : 23
i :  0 somme :  0
i :  1 somme :  1
i :  2 somme :  3
i :  3 somme :  6
i :  4 somme :  10
i :  6 somme :  16
i :  7 somme :  23
i :  8 somme :  23

Retour au sommaire

22 - Chaines

Chaînes de caractères

  1. Représentation et affichage d'une chaîne de caractères
  2. Cas des chaînes qui contiennent des guillemets ou des apostrophes
  3. Quelques caractères spéciaux
  4. Variables contenant une chaîne de caractères
  5. Longueur d'une chaîne
  6. Conversion d'un nombre en chaîne de caractères et inversement
  7. Egalité de chaînes de caractères
  8. Accès aux caractères individuels d'une chaîne de caractères
  9. Concaténation de chaînes
  10. Codage des caractères en informatique
  11. Ordre sur les chaînes de caractères
  12. Majuscules et minuscules
  13. Autres fonctionnalités sur les chaînes en Python

On traite ici le sujet des chaînes de caractères, qui sont des objets de type string (str) en Python, destinés à contenir des textes ou des messages. Notons qu'il n'existe pas en Python de type "_caractère_" comme dans d'autres langages de programmation. En Python, un caractère est simplement une chaîne composée d'un seul caractère. Les chaînes de caractères présentent de nombreuses similitudes avec les listes qui seront étudiées dans le chapitre suivant.

1- Représentation et affichage d'une chaîne de caractères

Une chaîne de caractères s'écrit entre guillemets qui peuvent être simples (c'est-à-dire des apostrophes) comme pour la chaîne 'Bonjour' ou doubles comme pour la chaîne "Bonjour". Une chaîne de caractères peut contenir aussi bien un seul caractère (et même zéro caractère) qu'un roman tout entier. 

type('Bonjour')

L'instruction print permet d'afficher une chaîne de caractères sans les guillemets qui l'entourent :

print("Bonjour")

2- Cas des chaînes qui contiennent des guillemets ou des apostrophes

Si l'on souhaite représenter un texte qui contient lui-même des guillemets doubles, on entourera la chaîne avec des guillemets simples :

print('Elle lui a dit "Bonjour!" puis elle est repartie.')

Inversement, si l'on souhaite représenter un texte qui contient des guillemets simples (apostrophes), on entourera la chaîne avec des guillemets doubles :

print("Je m'appelle Pierre.")
Exercice 1 : Ecrire un programme qui affiche les deux messages suivants avec une instruction print :
  • Le mot "amphigourique" est rarement utilisé.
  • L'informatique

3- Quelques caractères spéciaux

Pour afficher certains caractères spéciaux que l'on ne peut pas saisir directement dans une chaîne, on utilise comme caractère d'échappement l'antislash (backslash en anglais) \ :

  • \n : nouvelle ligne (aller à la ligne)
  • \t : tabulation
  • \' : apostrophe (utilisable dans une chaîne qui est entre apostrophes)
  • \\ : antislash \ 
print('Bonjour\nCeci est un très long texte\t sur plusieurs lignes.\nJe ne sais pas trop quoi raconter mais ce matin je me suis levé à l\'aube.')

Remarque : Un antislash en fin de ligne (sans aucun caractère après l'antislash, même pas un espace) permet d'écrire une instruction très longue sur plusieurs lignes.
L'instruction ci-dessous est une réécriture de l'instruction précédente, avec des longueurs de lignes plus raisonnables :

print('Bonjour\nCeci est un très long texte\t sur plusieurs lignes.\nJe ne sais pas trop quoi \
raconter mais ce matin je me suis levé à l\'aube.')

4- Variables contenant une chaîne de caractères

Une chaîne peut être stockée dans une variable :

a = 'rrr'
b = a
print(b)

Rappel : la fonction input renvoie une chaîne de caractère saisie par l'utilisateur. On stocke généralement cette chaîne dans une variable.

5- Longueur d'une chaîne

La fonction len renvoie la longueur d'une chaîne de caractères (len est l'abréviation de "length" qui signifie "longueur" en anglais) : 

len('Bonjour')

Remarque : les espaces et les retours à la ligne sont comptés comme des caractères, mais pas les caractères d'échappement :

len('a b c')
len('a\nb\nc')

6- Conversion d'un nombre en chaîne de caractères et inversement

La fonction str(nombre) permet de transformer le nombre donné en argument (de type int ou float) en une chaîne de caractères :

str(5)
str(4.6)
Exercice 2 : Reprendre l'exercice 6 du chapitre 5 sans utiliser de boucle while :
Ecrire un programme qui demande à l'utilisateur de saisir un nombre entier strictement positif et qui affiche le nombre de chiffres de ce nombre.

Inversement, une chaîne peut être transformée en type numérique avec les fonctions int et float. Ceci est nécessaire lorqu'on utilise la fonction input qui renvoie une chaîne de caractères et que l'on attend une valeur numérique. 

int("100")
float("37.2")

7- Egalité de chaînes de caractères

Comme pour les nombres, on peut tester l'égalité ou la non-égalité de deux chaînes de caractères avec les opérateurs == et !=.

Exercice 3 : Tester l'égalité des chaînes "Bonjour" et "BONJOUR".

8- Accès aux caractères individuels d'une chaîne de caractères

On accède aux caractères qui constituent une chaîne avec la notation [].
Attention, la numérotation commence à 0. Ainsi, mot[0] désigne le premier caractère de la chaîne mot.

Remarques :

  • On utilise la même syntaxe pour les chaînes de caractères que pour les listes (ou les tableaux en informatique) qui seront vues dans le prochain chapitre.
  • On ne peut pas modifier une chaîne de caractères déjà existante. Il faut créer une nouvelle chaîne à chaque fois qu'on souhaite apporter une modification à une chaîne. Ainsi, le code suivant provoque une erreur : 
mot = "mare"
mot[1] = "u"
Exercice 4 : Ecrire un programme qui affiche la première lettre d'un mot saisi par l'utilisateur.
Exercice 5 : Ecrire un programme qui affiche la dernière lettre d'un mot saisi par l'utilisateur.

Remarque : En Python, un raccourci pour accéder au dernier caractère d'une chaîne consiste à utiliser l'indice -1.
Ainsi, mot[-1] désigne le dernier caractère de la chaîne mot.

Exercice 6 : Ecrire un programme qui demande à l'utilisateur de saisir un mot, et qui affiche ce mot verticalement (sur une colonne).
Exercice 7 : Ecrire une fonction estPrésent(lettre,message) qui renvoie True ou False selon que la lettre est présente ou non dans le message. 
   

assert(estPrésent('a','abracadabra') == True)
assert(estPrésent('r','abracadabra') == True)
assert(estPrésent('R','abracadabra') == False)
Exercice 8 : Ecrire une fonction nbOccurences(lettre,message) qui renvoie le nombre d'occurences d'une lettre (ou d'un caractère) dans un message. 
def nbOccurences(lettre,message):
    pass

assert(nbOccurences('a','abracadabra') == 5)
assert(nbOccurences('A','abracadabra') == 0)

On peut parcourir une chaîne à l'aide d'une boucle en utilisant une syntaxe raccourcie, qui permet de faire en sorte que la variable de boucle contienne directement les caractères successifs de la chaîne :

mot = "table"
for c in mot:
    print(c)
Exercice 9 : Reprendre l'exercice 8 en utilisant la syntaxe raccourcie.

9- Concaténation de chaînes

A partir de deux chaînes de caractères, on peut construire une nouvelle chaîne qui est la concaténation des deux chaînes. On utilise pour cela l'opérateur + :

message = "Bonjour"
espace = " "
prénom = "Anna"
phrase = message + espace + prénom
print(phrase)

On peut utiliser la syntaxe abrégée pour la concaténation :

mot = 'vert'
mot += "e"
print(mot)

On pourrait croire à première vue que l'on modifie la chaîne initiale en la rallongeant d'un caractère, mais en fait on crée ici une nouvelle chaîne, qui est stockée à un emplacement différent de celui de la chaîne initiale. Ceci peut poser des problèmes d'efficacité si on utilise des chaînes très longues ou si on effectue de nombreux ajouts.
Pour ce genre de situation, il existe des moyens plus efficaces mais plus complexes à utiliser et hors programme de Première Spécialité NSI.

Remarque : Python offre aussi la possibilité de "multiplier" une chaîne par un nombre entier :

5 * "Tic Tac "

10- Codage des caractères en informatique

En informatique, chaque caractère est représenté ou codé par un nombre entier, compris entre 32 et 126 pour les caractères les plus courants, appelé le code ASCII (American Standard Code for Information Interchange) :

  • 32 : espace
  • 48-57 : chiffres 0-9
  • 65-90 : lettres majuscules A-Z
  • 97-122 : lettres minuscules a-z

La liste des 128 premiers codes est donnée ici : https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange

Les lettres accentuées et autres caractères spéciaux possèdent un code supérieur à 128.
Attention, les 32 premiers caractères sont des caractères de contrôle un peu particuliers (retour en arrière, saut de ligne, etc..), il vaut mieux éviter de les afficher. Plus de détails ici : https://fr.wikipedia.org/wiki/Caract%C3%A8re_de_contr%C3%B4le

On dispose en Python de deux fonctions pour passer d'un caractère à son code et inversement :

  • chr(code) : renvoie le caractère (sous forme d'une chaîne) correpondant au code donné en paramètre
  • ord(caractère) : renvoie le code correpondant au caractère (chaîne d'un seul caractère) donné en paramètre 
chr(65)
ord('B')
Exercice 10 : Ecrire un programme qui affiche toutes les lettres de l'alphabet en minuscule sur une seule ligne.

11- Ordre sur les chaînes de caractères

On peut comparer les chaînes de caractères entre elles avec les symboles <, >, <= et >=. L'ordre utilisé est l'ordre lexicographique. Le principe est le même que celui de l'ordre alphabétique : on compare d'abord le premier caractère de chaque chaîne. En cas d'égalité, on compare le deuxième caractère etc...
D'après le code ASCII, les chiffres sont inférieurs aux lettres majuscules, qui sont elles-mêmes inférieures aux lettres minuscules, qui sont elles-mêmes inférieures aux lettres accentuées.

"ananas" < "ane"
"Zèbre" < "ane"
"cheval" < "âne"
Exercice 11 : Les compraisons suivantes renvoient-elles True ou False ? "123" < "13" "a8" < "8A" "z" < "anticonstitutionnellement"
Exercice 12 : Ecrire un programme qui demande à l'utilisateur de saisir successivement deux mots écrits en minuscules (on évitera les lettres accentuées) puis qui les affiche l'un après l'autre dans l'ordre alphabétique.
Exercice 13 : Comme chaque année, lors de la rentrée universitaire, de nombreux étudiants viennent s’inscrire à la bibliothèque et une longue file d’attente se forme. Afin d’essayer d'accélérer les choses, les fiches d’inscription de tous les étudiants ont déjà été préparées et ils n’ont plus qu’à les récupérer.

Trois personnes sont en charge de distribuer les fiches : la première s’occupe des étudiants dont le nom commence par une lettre comprise entre A et F (inclus), la seconde personne des étudiants dont le nom commence par une lettre comprise entre G et P (inclus) et la troisième du reste des étudiants.

Quand un nouvel étudiant arrive, il donne son nom et il faut lui indiquer quelle personne il doit aller voir. Les noms des étudiants commencent par une lettre majuscule.

Ecrire une fonction personne(étudiant) qui renvoie le numéro (1, 2 ou 3) de la personne que l'étudiant doit aller voir.
Ajouter ensuite plusieurs instructions assert pour tester chacun des cas.
_Source : France IOI_

12- Majuscules et minuscules

Une chaîne de caractères est en réalité un "objet" qui dispose de fonctions (appelées des méthodes) toutes faites qui peuvent être appelées à tout moment sur l'objet concerné. Les bases de la programmation orientée objet seront étudiées en Terminale Spécialité NSI.
Par exemple, la fonction (ou méthode) upper appliquée à une chaîne de caractères renvoie la chaîne écrite en majuscules : 

chaine = 'Bonjour'
chaine.upper()

Remarque : La fonction upper renvoie une nouvelle chaîne sans modifier la chaîne à laquelle elle s'applique.

chaine

Voici quelques méthodes concernant les chaînes de caractères :

NomType de la valeur de retourRôle
upperStringRenvoie la chaîne écrite en majuscules
lowerStringRenvoie la chaîne écrite en minuscules
isupperBooleanRenvoie True si la chaîne est écrite en majuscules, False sinon
islowerBooleanRenvoie True si la chaîne est écrite en minuscules, False sinon
isalphaBooleanRenvoie True si la chaîne ne comporte que des lettres, False sinon
isnumericBooleanRenvoie True si la chaîne ne comporte que des chiffres, False sinon
Exercice 14 : Ecrire une fonction transforme(mot) qui prend en paramètre un mot écrit avec des majuscules et/ou des minuscules, et qui renvoie ce mot avec la première lettre en majuscule et les autres lettres en minuscule. 
# Votre fonction ici :



assert(transforme("fraise") == "Fraise")
assert(transforme("FRAISE") == "Fraise")
assert(transforme("fRAISE") == "Fraise")
assert(transforme("Fraise") == "Fraise")

13- Autres fonctionnalités sur les chaînes de caractères en Python

Il existe de nombreuses autres fonctionnalités (ou méthodes) sur les chaînes de caractères.
Voir ici: https://docs.python.org/fr/3/library/stdtypes.html?#string-methods

Merci, Thomas FOIRIEN !

Retour au sommaire

23 - Chaines Correction

Chaînes de caractères (Correction)

  1. Représentation et affichage d'une chaîne de caractères
  2. Cas des chaînes qui contiennent des guillemets ou des apostrophes
  3. Quelques caractères spéciaux
  4. Variables contenant une chaîne de caractères
  5. Longueur d'une chaîne
  6. Conversion d'un nombre en chaîne de caractères et inversement
  7. Egalité de chaînes de caractères
  8. Accès aux caractères individuels d'une chaîne de caractères
  9. Concaténation de chaînes
  10. Codage des caractères en informatique
  11. Ordre sur les chaînes de caractères
  12. Majuscules et minuscules
  13. Autres fonctionnalités sur les chaînes en Python

1- Représentation et affichage d'une chaîne de caractères

2- Cas des chaînes qui contiennent des guillemets ou des apostrophes

Exercice 1 : Ecrire un programme qui affiche les deux messages suivants avec une instruction print :
  • Le mot "amphigourique" est rarement utilisé.
  • L'informatique
print('Le mot "amphigourique" est rarement utilisé.')
print("L'infomatique")
Le mot "amphigourique" est rarement utilisé.
L'infomatique

3- Quelques caractères spéciaux

4- Variables contenant une chaîne de caractères

5- Longueur d'une chaîne

6- Conversion d'un nombre en chaîne de caractères et inversement

Exercice 2 : Reprendre l'exercice 6 du chapitre 5 sans utiliser de boucle while :
Ecrire un programme qui demande à l'utilisateur de saisir un nombre entier strictement positif et qui affiche le nombre de chiffres de ce nombre. 
chaine = input("Veuillez saisir un nombre entier strictement positif : ")
print(len(chaine))
Veuillez saisir un nombre entier strictement positif : 564
3

7- Egalité de chaînes de caractères

Exercice 3 : Tester l'égalité des chaînes "Bonjour" et "BONJOUR".
"Bonjour" == "BONJOUR"
False

8- Accès aux caractères individuels d'une chaîne de caractères

Exercice 4 : Ecrire un programme qui affiche la première lettre d'un mot saisi par l'utilisateur. 
mot = input("Veuillez saisir un mot ! ")
print(mot[0])
Veuillez saisir un mot ! Framboise
F
Exercice 5 : Ecrire un programme qui affiche la dernière lettre d'un mot saisi par l'utilisateur. 
mot = input("Veuillez saisir un mot ! ")
print(mot[len(mot)-1])
Veuillez saisir un mot ! Framboise
e

Remarque : En Python, un raccourci pour accéder au dernier caractère d'une chaîne consiste à utiliser l'indice -1.
Ainsi, mot[-1] désigne le dernier caractère de la chaîne mot.

Exercice 6 : Ecrire un programme qui demande à l'utilisateur de saisir un mot, et qui affiche ce mot verticalement (sur une colonne). 
mot = input("Veuillez saisir un mot ! ")
for i in range(len(mot)):
    print(mot[i])
Veuillez saisir un mot ! Framboise
F
r
a
m
b
o
i
s
e
Exercice 7 : Ecrire une fonction estPrésent(lettre,message) qui renvoie True ou False selon que la lettre est présente ou non dans le message. 
# Version 1
def estPrésent(lettre,message):
    résultat = False
    for i in range(len(message)):
        if message[i] == lettre:
            résultat = True
    return résultat

assert(estPrésent('a','abracadabra') == True)
assert(estPrésent('r','abracadabra') == True)
assert(estPrésent('R','abracadabra') == False)
# Version 2 plus courte et plus performante, on sort de la fonction dès qu'on a trouvé une occurence de la lettre
def estPrésent(lettre,message):
    for i in range(len(message)):
        if message[i] == lettre:
            return True
    return False

assert(estPrésent('a','abracadabra') == True)
assert(estPrésent('r','abracadabra') == True)
assert(estPrésent('R','abracadabra') == False)
Exercice 8 : Ecrire une fonction nbOccurences(lettre,message) qui renvoie le nombre d'occurences d'une lettre (ou d'un caractère) dans un message. 
def nbOccurences(lettre,message):
    compteur = 0
    for i in range(len(message)):
        if message[i] == lettre:
            compteur = compteur + 1
    return compteur

assert(nbOccurences('a','abracadabra') == 5)
assert(nbOccurences('A','abracadabra') == 0)
Exercice 9 : Reprendre l'exercice 8 en utilisant la syntaxe raccourcie. 
def nbOccurences(lettre,message):
    compteur = 0
    for c in message:
        if c == lettre:
            compteur = compteur + 1
    return compteur

assert(nbOccurences('a','abracadabra') == 5)
assert(nbOccurences('A','abracadabra') == 0)

9- Concaténation de chaînes

10- Codage des caractères en informatique

Exercice 10 : Ecrire un programme qui affiche toutes les lettres de l'alphabet en minuscule sur une seule ligne.
for i in range(ord('a'), ord('z') + 1):
    print(chr(i), end="")
abcdefghijklmnopqrstuvwxyz

11- Ordre sur les chaînes de caractères

Exercice 11 : Les compraisons suivantes renvoient-elles True ou False ? "123" < "13" "a8" < "8A" "z" < "anticonstitutionnellement" 
True
False
False
Exercice 12 : Ecrire un programme qui demande à l'utilisateur de saisir successivement deux mots écrits en minuscules (on évitera les lettres accentuées) puis qui les affiche l'un après l'autre dans l'ordre alphabétique.
mot1 = input("Veuillez saisir un mot : ")
mot2 = input("Veuillez saisir un autre mot : ")
if mot1 < mot2:
    print(mot1, mot2)    
else:
    print(mot2, mot1)
Veuillez saisir un mot : framboise
Veuillez saisir un autre mot : fraise
fraise framboise
Exercice 13 : Comme chaque année, lors de la rentrée universitaire, de nombreux étudiants viennent s’inscrire à la bibliothèque et une longue file d’attente se forme. Afin d’essayer d'accélérer les choses, les fiches d’inscription de tous les étudiants ont déjà été préparées et ils n’ont plus qu’à les récupérer.

Trois personnes sont en charge de distribuer les fiches : la première s’occupe des étudiants dont le nom commence par une lettre comprise entre A et F (inclus), la seconde personne des étudiants dont le nom commence par une lettre comprise entre G et P (inclus) et la troisième du reste des étudiants.

Quand un nouvel étudiant arrive, il donne son nom et il faut lui indiquer quelle personne il doit aller voir. Les noms des étudiants commencent par une lettre majuscule.

Ecrire une fonction personne(étudiant) qui renvoie le numéro (1, 2 ou 3) de la personne que l'étudiant doit aller voir.
Ajouter ensuite plusieurs instructions assert pour tester chacun des cas.
_Source : France IOI_

def personne(étudiant):
    if 'A' <= étudiant[0] <= 'F':
        return 1
    if 'G' <= étudiant[0] <= 'P':
        return 2
    return 3
    
print(personne('Fraise'))
print(personne('Moutarde'))
print(personne('Zorro'))
1
2
3

12- Majuscules et minuscules

Exercice 14 : Ecrire une fonction transforme(mot) qui prend en paramètre un mot écrit avec des majuscules et/ou des minuscules, et qui renvoie ce mot avec la première lettre en majuscule et les autres lettres en minuscule. 
# Votre fonction ici

def transforme(mot):
    résultat = mot[0].upper()
    for i in range(1,len(mot)):
        résultat = résultat + mot[i].lower()
    return résultat

assert(transforme("fraise") == "Fraise")
assert(transforme("FRAISE") == "Fraise")
assert(transforme("fRAISE") == "Fraise")
assert(transforme("Fraise") == "Fraise")

# Remarque : la méthode capitalize() effectue la même chose :
"aBcD".capitalize()
'Abcd'

13- Autres fonctionnalités sur les chaînes de caractères en Python

Retour au sommaire

24 - Etude de Fonction

Tracer des fonctions et étude des variations

Les fonctions mathématiques se représentent graphiquement par des courbes.
En langage Python, pour tracer la courbe représentative d'une fonction on peut utiliser les bibliothèques numpy et matplotlib.pyplot que l'on peut renommer avec les raccourcis respectifs np et plt.

Exemple :

On veut tracer les courbes représentatives des fonctions $f$ et $g$ définies sur $[-5;3]$ par :

  • $f(x) = 3x^2-2x-1$,
  • $g(x) = 2x-1$.
import matplotlib.pyplot as plt
import numpy as np

def f(x) :
    return 3*x**2-2*x-1

def g(x) :
    return 2*x-1

plt.clf()
plt.axis([-5,5,-10,20])
plt.grid()

x = np.linspace(-5,5,100)

plt.plot(x,f(x))
plt.plot(x,g(x))

# Dessiner les axes
plt.axhline(0, color='black', lw=2)
plt.axvline(0, color='black', lw=2)

plt.show()

L'instruction axis([valeur1,valeur2,valeur3,valeur4]) définit les dimensions du repère. Dans l'exemple les valeurs de l'axe des abscisses sont comprises entre -5 et 3 ; celles de l'axe des ordonnées sont compris entre -20 et 10.

L'instruction grid() permet d'afficher un quadrillage.

L'instruction linspace(valeur1,valeur2,nombre_points)définit l'intervalle dans le quel $x$ varie et le nombre de points calculés pour tracer la courbe.

Ici, $x$ varie dans l'intervalle $[-5;3]$ et la courbe représentatrive sera tracée avec 100 points.

La variable $y$ est calculée en fonction de $x$.

L'instruction plot(x,y) trace les points de coordonnées $x$ et $y$.

L'instruction show()permet l'affichage de la courbe (obtenu en exécutant le script).

Tableau de valeurs

import numpy as np
import pandas as pd

# Définition des fonctions
def f(x):
    return 3*x**2 - 2*x - 1

def g(x):
    return 2*x - 1

# Générer les valeurs de x
x = np.linspace(-5, 5, 11)  # 11 pour le nombre de valeurs

# Création d'un DataFrame pandas pour organiser les valeurs
data = {'x': x, 'f(x)': f(x), 'g(x)': g(x)}
df = pd.DataFrame(data)

# Afficher le DataFrame
print(df)

Intersections

import sympy as sp

# Définition des symboles
x, y = sp.symbols('x y')

# Définition des fonctions f(x) et g(x)
def f(x):
    return 3*x**2 - 2*x - 1

def g(x):
    return 2*x - 1

# Équation à résoudre : f(x) - g(x) = 0
equation = sp.Eq(f(x) - g(x), 0)

# Résolution de l'équation pour trouver les intersections
intersections = sp.solve(equation, x)

# Calcul des valeurs correspondantes de y
intersection_points = [(x_val, f(x_val)) for x_val in intersections]

# Affichage des intersections (x, y)
print("Intersections entre f et g :")
for x_val, y_val in intersection_points:
    print(f"x = {x_val}, y = {y_val}")

Etude de fonction

Le script ci-dessous, n'est pas parfait, car le module sympy a des limites !!!

# Version 1

import sympy as sp
import matplotlib.pyplot as plt
import numpy as np

x = sp.symbols('x')

def f(x):
    return 2*(x-2)*(x-3)*(x+1)

# Utilisation de sp.Rational pour des valeurs exactes
borne_inf = '-oo' # Utilisez '-oo' pour -∞
borne_sup = '+oo'  # Utilisez '+oo' pour +∞

# Convertir les entrées en valeurs sympy appropriées
borne_inf = sp.oo if borne_inf == '+oo' else (-sp.oo if borne_inf == '-oo' else borne_inf)
borne_sup = sp.oo if borne_sup == '+oo' else (-sp.oo if borne_sup == '-oo' else borne_sup)

f_expr = f(x)
print('f(x) =', f_expr)

f_prime = sp.diff(f_expr, x)
print("f'(x) =", f_prime)
print("f'(x) =", f_prime.simplify())  # Utilisez simplify() pour simplifier 

f_double_prime = sp.diff(f_prime, x)
print("f''(x) =", f_double_prime)

critical_points = sp.solve(f_prime, x)

# Trouver les points où la dérivée seconde est nulle (points d'inflexion)
inflection_points = sp.solve(f_double_prime, x)

# Adapter les intervalles pour l'analyse des variations en tenant compte de l'ensemble de définition spécifié
intervals = [borne_inf] + sorted([p for p in critical_points if borne_inf < p < borne_sup]) + [borne_sup]

print("\nVariations de f :")
for i in range(len(intervals) - 1):
    if intervals[i] == -sp.oo or intervals[i+1] == sp.oo:
        test_point = intervals[i] + 1 if intervals[i] != -sp.oo else intervals[i+1] - 1
    else:
        test_point = (intervals[i] + intervals[i+1]) / 2

    sign = f_prime.subs(x, test_point)
    variation = "f croît" if sign > 0 else "f décroît"
    print(f"{intervals[i]} < x < {intervals[i+1]}\t{variation}")

# Vérifier la concavité pour identifier les extremums locaux
extrema = []
for p in critical_points:
    if f_double_prime.subs(x, p) > 0:
        extrema.append((p, "Minimum local", f_expr.subs(x, p)))  # Ajout de la valeur de f(x)
    elif f_double_prime.subs(x, p) < 0:
        extrema.append((p, "Maximum local", f_expr.subs(x, p)))  # Ajout de la valeur de f(x)

for p in inflection_points:
    extrema.append((p, "Point d'inflexion", f_expr.subs(x, p)))  # Ajout de la valeur de f(x)

if extrema:
    print("\nExtremums locaux et points d'inflexion :")
    for p, type, value in extrema:
        print(f"x = {p}\t{type}\tf(x) = {value}")
else:
    print("\nAucun extremum local trouvé.")
    
# Afficher les zéros de la fonction (intersection avec l'axe des abscisses)
print("\nZéros de la fonction (intersection avec l'axe des abscisses):")
zeros = sp.solve(f_expr, x, domain=sp.S.Reals)
for zero in zeros:
    print(f"x = {zero}")
    

plt.clf()
plt.axis([-10,10,-20,20])
plt.grid()
x = np.linspace(-10,10,100)
plt.plot(x,f(x))
plt.axhline(0, color='black', lw=2)
plt.axvline(0, color='black', lw=2)
plt.show()
# Version 2

import sympy as sp
import matplotlib.pyplot as plt
import numpy as np

from IPython.display import display, Markdown

x = sp.symbols('x')

def f(x):
    return 2*(x-2)*(x-3)*(x+1)

# Utilisation de sp.Rational pour des valeurs exactes
borne_inf = '-oo' # Utilisez '-oo' pour -∞
borne_sup = '+oo'  # Utilisez '+oo' pour +∞

# Convertir les entrées en valeurs sympy appropriées
borne_inf = sp.oo if borne_inf == '+oo' else (-sp.oo if borne_inf == '-oo' else borne_inf)
borne_sup = sp.oo if borne_sup == '+oo' else (-sp.oo if borne_sup == '-oo' else borne_sup)

f_expr = f(x)
display(Markdown(f'$$f(x) = {sp.latex(f_expr)}$$'))

f_prime = sp.diff(f_expr, x)
f_prime_simplified = sp.simplify(f_prime)
display(Markdown(f'$$f\'(x) = {sp.latex(f_prime_simplified)}$$'))

f_double_prime = sp.diff(f_prime, x)
display(Markdown(f'$$f\'\'(x) = {sp.latex(f_double_prime)}$$'))

critical_points = sp.solve(f_prime, x)

# Trouver les points où la dérivée seconde est nulle (points d'inflexion)
inflection_points = sp.solve(f_double_prime, x)

# Adapter les intervalles pour l'analyse des variations en tenant compte de l'ensemble de définition spécifié
intervals = [borne_inf] + sorted([p for p in critical_points if borne_inf < p < borne_sup]) + [borne_sup]

display(Markdown("\nVariations de f :"))
for i in range(len(intervals) - 1):
    if intervals[i] == -sp.oo or intervals[i+1] == sp.oo:
        test_point = intervals[i] + 1 if intervals[i] != -sp.oo else intervals[i+1] - 1
    else:
        test_point = (intervals[i] + intervals[i+1]) / 2

    sign = f_prime.subs(x, test_point)
    variation = "f croît" if sign > 0 else "f décroît"
    display(Markdown(f'$$ {sp.latex(intervals[i])} < x < {sp.latex(intervals[i+1])}\t{variation} $$'))

# Vérifier la concavité pour identifier les extremums locaux
extrema = []
for p in critical_points:
    if f_double_prime.subs(x, p) > 0:
        extrema.append((p, "Minimum local  :", sp.simplify(f_expr.subs(x, p))))  
    elif f_double_prime.subs(x, p) < 0:
        extrema.append((p, "Maximum local  :", sp.simplify(f_expr.subs(x, p))))

for p in inflection_points:
    extrema.append((p, "Point d'inflexion  :", sp.simplify(f_expr.subs(x, p))))  

if extrema:
    display(Markdown("\nExtremums locaux et points d'inflexion :"))
    for p, type, value in extrema:
        display(Markdown(f'$$ {type}\tx = {sp.latex(p)}\tf(x) = {sp.latex(value)} $$'))
else:
    display(Markdown("\nAucun extremum local trouvé."))
    
# Afficher les zéros de la fonction (intersection avec l'axe des abscisses)
display(Markdown("\nZéros de la fonction (intersection avec l'axe des abscisses):"))
zeros = sp.solve(f_expr, x, domain=sp.S.Reals)
for zero in zeros:
    display(Markdown(f'$$ x = {sp.latex(zero)} $$'))
    

plt.clf()
plt.axis([-10,10,-20,20])
plt.grid()
x = np.linspace(-10,10,100)
plt.plot(x,f(x))
plt.axhline(0, color='black', lw=2)
plt.axvline(0, color='black', lw=2)
plt.show()

Retour au sommaire

↑ Haut de la page