Pour tester l’outil, voici quelques scripts Python, donnés en exemples, dans les onglets suivants :

Pour calculer les diviseurs d’un entier :

def diviseurs(unEntier):
	S = set([])
	for d in range(1,unEntier+1):
		if unEntier%d == 0:
			S.add(d)
	return S

Maintenant, les diviseurs communs à deux entiers :

def divComm(a,b):
	dA = diviseurs(a)
	dB = diviseurs(b)
	return dA.intersection(dB)

Enfin, le pgcd de deux entiers est le plus grand élément de cet ensemble :

def pgcd(a,b):
	return max(divComm(a,b))

Bien entendu on peut aussi calculer un pgcd par l’algorithme d’Euclide :

def euclide(a,b):
    while b!=0:
        a,b = b,a%b
    return a

Version classique, avec des affectations :

u = 65
while u >= 2:
	if u%2==0:
		u=u/2
	else:
		u=3*u+1
	print(u)

Et la version Sofus :

u = 65
while u >= 2:
	if u%2==0:
		u /= 2
	else:
		u *= 3
		u += 1
	print(u)

Extrait du sujet STI2D Polynésie 2017 :

Dans un parc régional, on étudie une espèce de renards. Cette population était de 1 240 renards à la fin de l’année 2016.
On modélise par u_n le nombre de renards dans le parc régional à la fin de l’année 2016+ n. On a donc u₀ = 1240.
On estime à 15 % par an la baisse du nombre u_n.
On suppose que cette évolution restera identique pour les années à venir.

Déterminer une estimation du nombre de renards présents dans le parc régional à la fin de l’année 2020.

u = 1240
for n in range(5):
	print(n,u)
	u = u-0.15*u

Déterminer la limite de la suite (u_n). Comment interpréter ce résultat ?

Tout d’abord on vérifie la formule explicite de la suite géométrique :

u = 1240
for n in range(5):
	print(n,1240*0.85**n)

Puis on va, comme dirait Buzz, « vers l’infini et au-delà » :

u = 1240
for n in [0,1,4,10,100,float('inf')]:
	print(n,1240*0.85**n)

Des scientifiques considèrent que l’espèce des renards présents dans le parc sera en situation d’extinction à partir du moment où le nombre de renards deviendra strictement inférieur à 100.
À partir de quelle année l’espèce de renards présents dans le parc sera-t-elle en situation d’extinction ?

u = 1240
n = 0
while u >= 100:
	n = n+1
	u = u-0.15*u

print(n)

Afin de préserver l’espèce, on décide d’introduire à chaque année 30 renards à partir de la fin de l’année 2017.
On note v_n le nombre de renards présents dans le parc à la fin de l’année 2016+n.
On estime à 15 % par an la baisse du nombre v_n.
On a v₀ = 1240.

v = 1240
n = 0
for n in range(100):
	print(v)
	v = v-0.15*v + 30

Dans le cas général on peut résoudre une équation du type f(x)=0 (« chercher un zéro de f ») par dichotomie :

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

def zero(f,a,b):
    if f(a)*f(b)>0:
        return None
    while(abs(a-b)>1e-14):
        m=(a+b)/2.
        if f(m)*f(a)>0:
            a=m
        else:
            b=m
    return m
    
print(zero(f,0,6))

Pour résoudre l’équation ax²+bx+c=0, on peut faire ainsi :

from math import *
def solutions(a,b,c):
        S = set([])
        Delta = b**2-4*a*c
        if Delta >= 0:
                r = sqrt(Delta)
                x1 = (-b-r)/(2*a)
                x2 = (-b+r)/(2*a)
                S.add(x1)
                S.add(x2)
        return S

Pour lancer un dé 600 fois puis voir la répartition de chaque face obtenue, on peut utiliser ce script :

from random import *

liste = []
for indice in range(600):
        result = randint(1,6)
	liste.append(result)

for face in range(1,7):
	print(face,liste.count(face))

Pour choisir un nombre premier au hasard, on peut faire

from random import *

print(choice([2,3,5,7,11]))

Pour simuler une variable aléatoire binomiale de paramètres 8 et 0,4 on peut passer par une approximation hypergéométrique, basée sur un tirage sans remise (comme 8 est petit par rapport à la taille 100 de l’urne, ça revient presque au même). On commence donc par remplir une urne, avec 40 boules rouges et 60 boules bleues, puis on y effectue des tirages de 8 boules, et à chaque fois, on compte le nombre de boules rouges :

from random import *

urne = ['rouge']*40+['bleu']*60

liste = []
for tirage in range(1000):
	echantillon = sample(urne,8)
	rouges = echantillon.count('rouge')
	liste.append(rouges)

for nsucces in range(9):
	print(nsucces,liste.count(nsucces))

Pour simuler une variable aléatoire exponentielle de paramètre 0,5 on fait

from random import *

print(expovariate(0.5))

Et pour simuler une variable aléatoire normale de paramètres 25 et 3,5 on fait

from random import *

print(gauss(25,3.5))

Pour dessiner un coquillage à motif hexagonal :

from turtle import *

def hexagone(cote):
	for etape in range(6):
		forward(cote)
		left(60)
for longueur in range(20):
	hexagone(10*longueur)
	left(18)

La recette du mouvement brownien est assez simple :

from turtle import *
from random import *
speed(0)
for pas in range(100):
	left(uniform(0,360))
	forward(5)

D’autres utilitaires sont présentés ici :

Le script suivant affiche dans la console, l’état des variables, à chaque fois qu’on invoque la fonction voir() :

def voir():
    v = {k:v for k,v in globals().iteritems() if k[:2]!="__" and k!="voir"}
    print(v)
 

On peut l’utiliser par exemple de cette manière :

S = 0
for n in range(8):
    S = S+n
    voir()

Certes on pouvait avoir le même effet avec

S = 0
for n in range(8):
    S = S+n
    print(n,S)

et les variables sont automatiquement affichées dans l’onglet variables de Spyder. Mais cette variante dessine vraiment les boîtes avec les étiquettes collées dessus :

#! /usr/bin/python3
# -*- coding: utf-8 -*-
from graphviz import Digraph

def voir(nom="boite1",afficher=True):
	g = Digraph(format='png')
	v = {k:v for k,v in globals().iteritems() if k[:2]!="__" and k!="voir" and k!="Digraph"}
	for k in v:
		g.node(k,k,shape="note",style="filled",fillcolor="lightyellow")
		g.node(str(v[k]),str(v[k]),shape='box3d',style="filled",fillcolor="orange")
		g.edge(k,str(v[k]))
	g.render(nom,view=afficher)

Ce script engendre des dessins :

S = 0
for n in range(8):
	S = S+n
	voir("somme"+str(n),False)

Les dessins portent les noms somme0, somme1 etc et peuvent ensuite être assemblés pour faire un dessin animé.