Voici un ensemble de fonctions qui permet de traiter différentes formes de représentation graphique. A tester.

# coding: utf-8
'''
======================
Initiation à Matplotlib
Formation Python Académie de Reims 2019-2020
====================
'''
from math import *
from random import *
import matplotlib.pyplot as plt # importation classique du module matplotlib.pyplot sous l'alias plt
import numpy as np

# La première ligne permet d'éviter des soucis d'encodage
# Suit l'entête qui présente le programme
# Les quatre lignes suivantes importent des modules qui nous seront nécessaires.
# Par défaut, on gagnera à mettre ces lignes en début de chaque programme.

def f(x):
    return x**2

def demo1():
    "Affiche basique la courbe de la  fonction f"
    # A partir de deux listes, on peut créer un graphique.
    # La première instruction crée le graphique et nous verrons que l'on peut ajouter des éléments supplémentaires à ce graphiqe.
    # La seconde instruction affiche l'ensemble.
    lx=np.linspace(-2,2,15) #crée une liste de 15 nombres allant de -2 à 2
    # On peut créer une listes de valeurs en calculant les images de tous les éléments de lx en écrivant f(lx):
    plt.plot(lx,f(lx))
    plt.show()

def demo2():
    "Affiche avec quelques options la courbe de la  fonction f"
    lx=np.arange(-4,6,0.01)
    plt.title("demo2")
    plt.plot(lx,f(lx),color='r')
    plt.axis([-3,4,-1,17])
    plt.axhline(color="b")
    plt.axvline(color="g")
    plt.show()


def demo3():
    " Création d'un histogramme à pas inégaux"
    plt.title("demo3")
    lvaleurs=[2,5,5,5,7,8,8,9,9,9,10,10,12,13,13,15,17,18,19]
    lbornes=[0,6,8,10,12,15,18,20]
    plt.hist(lvaleurs,lbornes,normed=True)

    plt.savefig("graphique.png")  #que l'on peut-même enregistrer comme image
    plt.show()   #Affichage du graphique

def demo4():
    "Affichage d 'un nuage de points aléatoires"
    lx=np.random.uniform(0,1,1000)
    ly=np.random.uniform(0,1,1000)
    plt.title("demo4")
    plt.scatter(lx,ly,color="r")
    plt.axis([-0.2,1.2,-0.2,1.2])
    plt.axhline(color="k")
    plt.axvline(color="k")
    plt.show()

def demo4b(nb=1000):
    "Affichage d 'un nuage de points aléatoires et test de leurs présence dans un dique"
    plt.title("demo4b")
    plt.axhline(color="k")
    plt.axvline(color="k")
    disque=0
    for i in range(nb):
        x=uniform(-1,1)  #Renvoie un nombre aléatoire de entre -1 et 1
        y=uniform(-1,1)
        R=sqrt(x**2+y**2)
        if R<1:
            plt.plot(x,y,"og")
            disque=disque+1
        else:
            plt.plot (x,y,"or")
        #plt.pause(0.01)  #fonctionne mal sous Jupyter mais bien sous EduPython
    print(disque/nb)
    print(disque/nb)
    plt.show()




# In[11]:


def g(x,a=1):
    return 1/(x-a)
def demo5():
    'Annotations dans un graphique en Latex et  Axes du repère'
    lx= np.linspace(-1,4,120)
    plt.plot(lx,g(lx,2),'rx')
    plt.title("demo5")
    #Déplace les axes du repère
    #Aller voir : https://python.developpez.com/tutoriels/graphique-2d/matplotlib/#LII-G
    ax = plt.gca()
    ax.spines['right'].set_color('none')
    ax.spines['top'].set_color('none')
    ax.xaxis.set_ticks_position('bottom')
    ax.spines['bottom'].set_position(('data',0))
    ax.yaxis.set_ticks_position('left')
    ax.spines['left'].set_position(('data',0))


    #xy=(1, 0) désigne la pointe de la flèche
    #xytext=(-120, +30) désigne le décalage du texte par rapport à cette pointe

    plt.annotate(r"$(\frac{1}{x-a})$ n'est pas définie en $a$",
             xy=(2, 0), xycoords='data',
             xytext=(-100, +30), textcoords='offset points', fontsize=16,
             arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
    plt.show()


def demo6():
    "afficher plusieurs sous-graphique dans un même graphique"
# En testant puis en copiant-collant le code ci-dessous, afficher les graphiques des fonctions composées nommées g,h,k et définies par (f(x)+2) ; (f(x+2)) et (-f(x)) en y ajoutant tous les commentaires nécessaires.


    lx= np.linspace(-3, 3, 100) #rempli la liste lx de valeurs allant de -2 à 2

    plt.subplot(221)  #Pour s'occuper du graphique numéro dans un tableau de graphique 2×2
    plt.subplots_adjust(hspace=0.4)  #Pour espacer les graphiques

    plt.title("Graphique 1 de la demo6")
    plt.plot(lx,f(lx))

    plt.subplot(222)
    plt.title("Sous Graphique 2")
    plt.plot(lx,f(lx))

    plt.subplot(223)
    plt.title("Sous Graphique 3")
    plt.plot(lx,f(lx))

    plt.subplot(224)
    plt.title("Sous Graphique 4")
    plt.plot(lx,f(lx))


    plt.show()


def h(x):
    if x<0:
        return -x
    else:
        return x

def demo7():
    "Le graphique d'une fonction qui n'est pas définie par une simple formule"
    lx=np.arange(-4,6,0.5)
    #ly=f(lx) cette commande ne peut alors pas fonctionner car on ne peut effectuer le test lx<0
    # Il faut plutôt faire la méthode suivante pour forcer le calcul pour chaque élément de la liste
    ly=[h(x) for x in lx]   #la liste ly est crée à partir de chaque élément de la liste lx
    plt.title("demo7")
    plt.plot(lx,ly)
    plt.show()

def demo8():
    "Et pour aller plus loin"
    "Tout est possible, le mieux est toujours de partir d'exemples et de les copier-coller pour se les approprier"
    lx=np.linspace(-3,5,20) #Une liste de 20 nombres de -2 à 2

    plt.title("La courbe de la fonction f demo8")
    plt.plot(lx,f(lx))
    plt.xlim(-3,5)
    plt.ylim(-5,5)
    plt.scatter(-1,f(-1))
    plt.show()

def demo9():
    "encore plus loin"
    lx=np.linspace(-3,5,20) #Une liste de 20 nombres de -2 à 2

    plt.title("La courbe de la fonction f demo9")

    lx=np.linspace(-10,10,200)
    plt.plot(lx,f(lx),"r--",label='Courbe de f')  #Pour la couleur et la forme

    lx2=np.linspace(-10,10,20)  #seulement 20 points
    plt.plot(lx2,f(lx2),"o", label='Images des entiers')

    plt.grid(True)          #Pour afficher une grille
    plt.ylim(-2,20)
    plt.legend(loc='upper right')  #Pour afficher les label définis plus haut
    plt.savefig('Courbe de f.png')  #On peut même l'enregistrer dans un fichier image
    plt.show()


def demo10(xmin=-10,xmax=+10,pas=0.001,lxp=[-6,-4,2,3],p_graduations_abs=1,p_graduations_ord=2):
    "Affiche la courbe de f dans un repère quadrillé en parquant les points dont les abscisses sont dans lxp"
    "et la graduation de la grille dans p_graduations_abs=1,p_graduations_ord=2"
    lx=np.arange(xmin,xmax+pas,pas)
    #ly=f(lx)
    ly=[f(x) for x in lx]
    ymin,ymax=min(min(ly),0),max(max(ly),0) #valeurs min et max de l'axe des ordonnées


    plt.title("La courbe de la fonction f demo10")
    plt.xlim(xmin,xmax) # valeurs min et max de l'axe des abscisses
    plt.axis([xmin,xmax,ymin,ymax])
    plt.yticks(range(int(ymin),int(ymax+1),p_graduations_ord)) # graduations des axes des ordonnées
    plt.xticks(range(int(xmin),int(xmax+1),p_graduations_abs)) # graduations des axes des abscisses
    plt.grid(True) #affiche un quadrillage
    # plt.axis('equal')
    # plt.title("fonction de la leçon")
    axes = plt.gca()
    axes.spines['right'].set_color('none')
    axes.spines['top'].set_color('none')
    axes.xaxis.set_ticks_position('bottom')
    axes.spines['bottom'].set_position(('data',0))
    axes.yaxis.set_ticks_position('left')
    axes.spines['left'].set_position(('data',0))


    plt.plot(lx,ly) # Affichage dela courbe de f

    lyp=[f(x) for x in lxp]  # Affichage des points supplémentaires
    plt.scatter(lxp,lyp,c='red',marker='x')

    plt.show()  #Affichage du graphique

def demo():

    demo1()
    demo2()
    demo3()
    demo4()
    demo4b(300)
    demo5()
    demo6()
    demo7()
    demo8()
    demo9()
    demo10(-4,4,lxp=[-1,0,1])

demo()

Fluctuation des frèquences de succès. Animation tirée de l'espace Eduscol. Ressources n°8 d'Eduscol

from math import *


def milieu(xA,yA,xB,yB):
    """ Renvoie les coordonnées du milieu du segment [AB]
    pour appeler la fonction milieu, il faut écrire milieu(1,1,3,-1) pour A(1;1 et B(3;-1)"""

    return (xA+xB)/2,(yA+yB)/2


# Ecrire la fonction distance(xA,yA,xB,yB) qui renvoie la distance AB

def distance(xA,yA,xB,yB):
    """ Renvoie la distance AB
    pour appeler la fonction distance, il faut écrire distance(1,1,3,-1) pour A(1;1) et B(3;-1)"""

    d=sqrt((xB-xA)**2+(yB-yA)**2)
    # x**2 correspond à x²
    # sqrt(x) correspond à la racine carrée de x
    return d

# méthode 1 : cette commande fonctionne si les deux fichiers sont dans le même dossier.
from analytique import *
	

# méthode 2 : cette commande fonctionne si le fichier est dans le sous-dossier module
from module.analytique import *
	

# Méthode 3 : créer votre module dans C:/EduPython/Lib/site-packages
from analytique import *
	

# Méthode 4 : plus compliquée
import sys
sys.path
sys.path.append("C:\\Users\\Pascal\\Google Drive\\Lycée général\\Python\\ModulesPersonnels")   # Chemin à adapter à votre configuration
	

from analytique import *
distance(1,1,2,2)
help(distance)