Demandez le programme !

La modularité apparaît dans la rubrique "structure des données" : le lien est établi avec la notion de modularité qui figure dans la rubrique « langages et programmation » en mettant en évidence l’intérêt d’utiliser des bibliothèques ou des API (Application Programming Interface).

Rubrique : langages de programmation

Souvenez vous, vu en première (les imports et les docstrings):

Les imports

Nous avons vu les fonctions print et input. Ce sont deux fonctions prédéfinies dans le langage Python, On appelle ce type de fonction des fonctions natives au langage Python , elles sont directement utilisables.

D'autres fonctions ont été développées et testées par différents programmeurs mais ne sont pas directement utilisables. Ces fonctions sont regroupées dans des modules, appelés aussi bibliothèques. En terminale, vous apprendrez même à en créer par vous même !

  • le module math contient de nombreuses fonctions mathématiques usuelles comme la racine carrée (sqrt), ...

  • le module random contient de nombreuses fonctions modélisant le hasard comme l'obtention d'un nombre entier aléatoire compris entre deux nombres entiers a et b (randint(a,b)), ...

  • le module matplotlib.pyplot permet de réaliser des graphiques, des tracés de courbes, ...

Pour pouvoir utiliser ces fonctions, il faut d'abord importer ces modules. Pour cela, il y a plusieurs méthodes :

Les docstrings

On peut écrire des indications de sur la fonction :explications, paramètres,... :

import math

def racine_carre(a):
    """Renvoie la racine carrée du paramètre a"""
    return math.sqrt(a) 
 

Appel pour accéder à cette documentation :

help(racine_carre)

Un autre type d'appel :

racine_carre.__doc__

Vous retrouverez une version synthétique en vidéo :

Un lien intéressant : Suivre ce lien

Ecrire une fonction est_impair(a) avec comme paramètre un entier positif a. Cette fonction revoie un booléen. Pour cette fonction, vous devez :
  • Ecrire un docstring qui indique ce que fait la fonction.
  • Ecrire un ou des assert pour le respect du "cahier des charges" de la fonction.
  • Etre capable d'accéder à vos commentaires.

Les notions de modules, bibliothèque et d'API

Lorsque l'on cherche à écrire un programme, on utilise des souvent des structures déjà existantes. Ces structures sont disponibles dans des modules et/ou des bibliothèques. En python, il existe une bibliothèque native qui contient de nombreux outils . Il existe de nombreuses bibliothèques disponibles en langage python.

Un point sur le vocabulaire utilisé :

En python vous pouvez créer votre module. Lorsque l'on créé un module, il faut le documenter de manière précise pour permettre son utilisation. Il faut également organiser des tests pour s'assurer de son bon fonctionnement. La documentation et les tests doivent être accessibles facilement pour une bonne prise en main du module.

Module et bibliothèque

Lien avec le langage python

Utilisation de la bibliothèque doctest de python

Une vidéo sur l'utilisation de cette bibliothèque en ligne de commandes :

Un exemple à traiter en téléchargeant le fichier jupyter : Lien ici

Aperçu du fichier :

Un module intéressant : le module turtle de python

Une explication en vidéo :

A vous de vous documenter !

Vous devez utiliser la documentation de turtle et réalisez un un dessin avec :

Clin œil à Stéphane ROEBROECK 😉

Réalisez les figures suivantes avec le module turtle

Tester et utiliser le code suivant :

En jupyter turtle provoque une erreur, il faut le forcer en exécutant une deuxième fois.
import turtle
turtle.speed('fast')


def carre(x,y,c):
    """
    à partir du point de coordonnées (x;y) et de côté c (points)"""
    turtle.up() #lève le stylo
    turtle.goto(x,y) #se rend sur le point de coordonnées (x;y)
    turtle.down() #descend le stylo
    for i in range(4):
        turtle.forward(c)
        turtle.left(90)



carre(-100,-100,50)
turtle.mainloop() # Pour sortir en python

# turtle.exitonclick()
# Pour sortir en jupyter
# Attention en jupyter il faut forcer l'exécution une deuxième fois

			

Code de déblocage de la correction :

Les deux TP qui suivent peuvent être le point de départ d'un projet ou d'un mini projet.

Un TP (difficile mais au rendu très chouette) proposé par un enseignant de la liste de diffusion NSI (Adrien WILLM)

Une vidéo comme consigne :

Le TP à télécharger : téléchargement ici

Pour vous aider, le dessin du sol et deux rectangles.

En jupyter turtle provoque une erreur, il faut le forcer en exécutant une deuxième fois.
import turtle

from random import randint, shuffle

def couleur_aleatoire():
    turtle.colormode(255)
    r = randint(0,255)
    g = randint(0,255)
    b = randint(0,255)
    return (r,g,b)

def trait(x1,y1,x2,y2):
    '''
    Paramètres
        x1, y1 : coordonnées du début du trait
        x2, y2 : coordonnées de la fin du trait
    '''
    turtle.penup()
    turtle.goto(x1,y1)
    turtle.pendown()
    turtle.goto(x2,y2)

def rectangle(x,y,w,h):
    '''
    Paramètres
        x, y : coordonnées du centre de la base de rectangle
        w : largeur du rectangle
        h : hauteur du rectangle
    '''
    turtle.penup()
    turtle.goto(x-w/2,y)
    turtle.pendown()
    turtle.goto(x+w/2,y)
    turtle.goto(x+w/2,y+h)
    turtle.goto(x-w/2,y+h)
    turtle.goto(x-w/2,y)


# ----- Sol de la rue -----
def sol(y_sol):
    '''
    Paramètres
        y_sol : ordonnée du sol du la rue
    '''
    turtle.pensize(3)
    trait(-380, y_sol, 380, y_sol)


# ----- Le programme -----

if __name__ == "__main__":
    turtle.setup(800, 600)
    turtle.speed(0)
    turtle.hideturtle()

    y_sol = -200
    # Dessin du sol de la rue
    sol(y_sol)

    rectangle(-100,y_sol,100,200)

    rectangle(100,y_sol,50,300)

    turtle.exitonclick()

A vous de créer des fonctions :

Vous pouvez vous répartir le travail et travailler en mode coopératif

Code de déblocage de la correction :

Un autre TP (difficile) pour utiliser le module turtle comme simulateur de déplacements d'un robot.

Vous trouverez en vidéo le rendu des simulations :

Pour vous aider, le dessin de la pièce.

En jupyter turtle provoque une erreur, il faut le forcer en exécutant une deuxième fois.
# -*- coding:utf-8 -*-
from math import *
from random import *
import matplotlib.pyplot as plt
import numpy as np

from turtle import * 
clear()

# structure en listes P pour pièce, O pour obstacle, R pour repère
# Les obstacles sont modélisés par des rectangles.

P0=(0,0)
P1=(200,0)
P2=(200,300)
P3=(0,300)
piece=[P0,P1,P2,P3]

O11=(170,130)
O12=(200,130)
O13=(200,180)
O14=(170,180)
Obstacle1=[O11,O12,O13,O14]

O21=(120,220)
O22=(200,220)
O23=(200,270)
O24=(120,270)
Obstacle2=[O21,O22,O23,O24]

O31=(0,100)
O32=(50,100)
O33=(50,200)
O34=(0,200)
Obstacle3=[O31,O32,O33,O34]


O41=(150,0)
O42=(200,0)
O43=(200,50)
O44=(150,50)

Obstacle4=[O41,O42,O43,O44]

Po0=(0,220)
Po1=(10,220)
Po2=(10,290)
Po3=(0,290)

Porte=[Po0,Po1,Po2,Po3]

C11=(140,210)
C12=(180,210)
C13=(180,220)
C14=(140,220)

Chaise1=[C11,C12,C13,C14]


C21=(110,225)
C22=(120,225)
C23=(120,265)
C24=(110,265)

Chaise2=[C21,C22,C23,C24]

# Les point repères

R0=(10,10)
R1=(100,60)
R2=(100,180)
R3=(60,250)


# Les points objectifs

O1=(120,270)
O2=(120,220)
O3=(10,250)
O4=(150,30)



# Structure en dictionnaire
# piece={'A':(0,0),'B':(200,0),'C':(200,300),'D':(0,300)}
# Obstacle3={'O31':(0,100),'032':(50,100),'033':(50,200),'034':(0,200)}


def X(point):
    return point[0]

def Y(point):
    return point[1]

def distance(A,B):
    return sqrt((B[0]-A[0])**2+(B[1]-A[1])**2)

def DessinerSegment(A,B):
    up()
    goto(A[0],A[1])
    down()
    goto(B[0],B[1])


def  DessinerPoygone(liste):
    listeTemp=liste
    listeTemp.append(listeTemp[0])
    up()
    goto(X(liste[0]),Y(liste[0]))
    down()
    for k in range(len(liste)-1):
        A=listeTemp[k]
        B=listeTemp[k+1]
        DessinerSegment(A,B)

def DessinerPiece():
    DessinerPoygone(piece)
    DessinerPoygone(Porte)
    DessinerPoygone(Obstacle3)
    DessinerPoygone(Obstacle2)
    DessinerPoygone(Obstacle1)
    DessinerPoygone(Obstacle4)
    DessinerPoygone(Chaise1)
    DessinerPoygone(Chaise2)

def initialiser(x,y):
    up()
    goto(x,y)
    down()

def DeplacementAleatoire(x,y):
    """Attention, il n'y a pas de tests de bords de la pièce dans ce déplacement
    """
    L=([-20,-10,0,10,20])
    d1=choice(L)
    d2=choice(L)
    return x+d1,y+d2


DessinerPiece()
exitonclick()

			

Code de déblocage de la correction :

Lien avec la programmation orientée objet

Vous pouvez vous reporter à l'exemple 14 de notre cours sur la programmation orientée objet, rubrique "prolongements". Lien direct vers POO, cherchez l'exemple 14

La notion d'API (Application Programming Interface)

Une API (Application Programming Interface) est une interface de programmation d'application. Cette interface est destinée à être utilisée par des programmes. Elle est composée de fonctions, constantes, classes. Dans une API, on met l'accent sur l'utilisation et la documentation. Les mécanismes internes et le fonctionnement de certaines composantes ne sont pas décrits. On peut faire un parallèle avec une automobile. Vous avez une documentation présentant certaines caractéristiques de votre automobile. Par contre, on ne vous livre pas le manuel détaillé du fonctionnement interne du moteur.

Regarder la vidéo et faire les différents tests. Vous pouvez modifier les fichiers en téléchargement pour faire d'autres tests.

API web

Dans une API web, il y a un échange de données avec des formats qui se sont standardisés dans le temps. Il existe essentiellement deux formats XML(Extensible Markup Language) et JSON (JavaSript Objet Notation).

Dans le fichier jupyter vous trouverez quelques exemples d'utilisation d'API disponibles sur le web.

Aperçu du fichier :

Lien ici

Code de déblocage de la correction :

Bibliographie et sitographie

Savoir et Savoir faire


Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International