Tester le code suivant :

>>>a=input("Entrer un nombre")
>>>b=a*10
>>>print(b)
                

Pourquoi cet affichage ?

Tester la code suivant (qui vous permet de connaître le type en python)

>>>type(a)

Transformer votre code de la manière suivante :

>>>a=int(input("Entrer un nombre"))
>>>b=a*10
>>>print("Votre nombre multiplié par 10",b)
                

def affichage(mot1,mot2):
    print(mot1,mot2)
    

affichage("maths ","Python ")

Transformer cette procédure en ajoutant return None à la fin de la fonction affichage . Tester la procédure.

Chercher l'erreur ( il y a une erreur à corriger).

def carre(x):
return x**2 
    
print(carre(1.7))

Chercher l'erreur ( il y a une erreur à corriger).

def quotient(x,y)
    return x/y

Ecrire une procédure qui prend en entrée deux variables nb1 et nb2 et qui affiche la moyenne des deux variables.

Ecrire une fonction moyenne(nb1,nb2) qui a pour paramètres deux variables de type float et qui renvoie la moyenne de ces deux nombres.

Ecrire une fonction vitesse(d,t), qui a pour paramètres deux variables de type float correspondant la distance d en mètre et le temps de parcours t en seconde et qui renvoie la vitesse en m/s.

Soit $f$ la fonction définie sur $\mathbb{R}$ par $f(x)=|x-3|$.

Ecrire une fonction f(x) qui prend en paramètre une variable de type float et qui renvoie un objet de type float correspondant à l'image de $x$ par $f$.

On n'utilisera pas la fonction abs(x) correspondant à $|x|$.

Abonnement et réseau social

Niveau : accessible

Inspiré du programme de SNT

" Un abonnement sur un réseau social de vidéo coûte 9.99 € par mois avec trois mois d 'essai gratuit pour une seule personne ou 15.99 € avec 1 mois d'essai gratuit pour toute la famille ".

Compléter la fonction suivante qui a pour argument le nombre de mois et qui renvoie le prix à payer.

def prix(mois):
	abonnement=input("Abonnement ? : seul ou famille ? ")
	# faire afficher "abonnement minimal d 'un an" si le nombre de mois est inférieur à 12
	# ...
	return(prix)
				

Tester la fonction avec :

print(prix(12))

Vous devriez observer :

Abonnement ? : seul ou famille ? seul 89.91

On donne une suite $u_{n}$ définie par sa relation de récurrence :

Ecrire une fonction u(n) qui a pour argument une variable n de type int et qui renvoie le terme d'indice $n$ de la suite $u$.

Le but est compter le nombre de 'e' dans une phrase.

def nbre_de_e(phrase):
    compteur=0
    for lettre in phrase:
        if lettre=="e":
            compteur=compteur+1
    return compteur

print("Le nombre de e est :",nbre_de_e("hello world!"))
			

Transformer l'algorithme pour qu'il compte le nombre de voyelles.

Simulation du lancer d'un dé

from random import randint # on importe le module randint de random
liste=[randint(1,6) for i in range(1000)]
print(liste)

Utiliser le code de l'exercice précédent pour compter le nombre de 1 de la liste.

On donne une suite $u_{n}$ définie par sa relation de récurrence :

On cherche l'indice $n$ tel que $u_{n} \ge 300 $

On a l'algorithme en pseudocode suivant :

u ← 0
n ← 0
tant que u < 300 faire
	n ← n+1 
	u ← u+1

Cet algorithme donne le programme suivant :

from math import *
u=0
n=0
while u <300:
	n=n+1
	u=3*u+1

print(n, u)

Longueur de courbe

Pour obtenir l'approximation de la longueur d'une courbe représentative d'une fonction $f$ sur un intervalle $[a;b]$. On peut découper $[a;b]$ en $n+1$ intervalles et ajouter les longueurs des $n+1$ segments d'extrémitées $A(x_n,f(x_n))$ et $B(x_{n+1},f(x_{n+1}))$

Ecrire une fonction long(f,a,b,nb) qui renvoie l'approximation de la longueur de la courbe représentative de $f$ sur l'intervalle $[a;b]$ avec nb intervalles.

Téléchargements des fichiers :

• format docx
• fichier jupyter

Les 8 erreurs

Retrouver les 8 erreurs dans ce code :

def makeList(deb,fin,max)
lst==[]
    s=0
    while s<max
    a=randint(deb,fin)
    lst.randint(a);
    s=s+a
    return lst,a

Activité proposée par Stéphane ROEBROECK

Vous avez un "bac à sable" à disposition pour vos essais.

Une activité qui permet d'appréhender l'algorithme de dichotomie.
• Première phase
1. Mettez-vous par deux et faîtes le jeu suivant : l’un des deux choisit un nombre entier au hasard entre 1 et 100, il le note quelque-part. L’autre doit retrouver le nombre. Pour cela, il fait des tentatives. A chaque tentative son ou sa camarade lui dit si c’est le bon nombre ou pas, et, si nécessaire, si le nombre proposé est trop grand ou trop petit. Notez le nombre de tentatives pour trouver le bon nombre.
2. Refaire plusieurs fois le jeu et en changeant les rôles. Créer un tableau qui comptabilise le nombre de tentatives pour chaque parties.
3. Imaginez que vous êtes seuls chez vous et vous souhaitiez rejouer. Vous allez écrire un programme pour remplacer celui du binôme qui choisit un nombre au hasard.
Pour vous y aider nous allons tester quelques séquences dans la console (ou le "bac à sable")
1. Exécuter from random import randint puis faire plusieurs fois randint(1,6) (remarque : la ligne doit toujours débuter par trois chevrons si vous êtes en mode console). Qu’obtenez-vous ?
2. for i in range(10) : randint(1,6) . Qu’obtenez-vous ?

3. c=1
   while c<=10 :
   	randint(1,6)
   	c=c+1
   	

   Qu’obtenez-vous ?
4. Entrez 5/2 puis 5//2 Quelle différence observez-vous ?
5. Entrez int(2.5) puis int(2.9) puis int(3.1)puis int(-2.2) . A quoi sert la fonction int() ?
6. Ecrire ci-dessous un algorithme susceptible de remplacer le joueur qui cherche à faire deviner le nombre.
7. Traduire cet algorithme en python, l’écrire dans l’éditeur d’edupython et le tester.
• Deuxième phase
1. Reprenez le tableau des tentatives réalisées lors de la séances précédentes. Pour chacun des deux « chercheurs », calculez le nombre moyen de tentatives :
2. Décrire la méthode que vous utilisez.
3. Avec les autres binômes, discutez de la meilleure méthode à utiliser.
4. Décrire la méthode dite "par dichotomie"
5. Modifiez le programme écrit lors de la première séance pour faire jouer le programme contre lui-même.
6. Ajouter les lignes nécessaires pour que le programme affiche à la fin de la recherche le nombre qu’il fallait trouver ainsi que le nombre de tentatives qui ont été nécessaires pour le retrouver. Vous réalisez ainsi la simulation de deux personnes qui jouent au jeu du « nombre à retrouver ». Faîtes tourner le programme plusieurs fois. Ce programme fait-il mieux que vous ?
7. Pour ceux qui ont bien avancé : compléter de nouveau le programme pour qu’il effectue autant de simulations que l’on souhaite et qu’il fasse la moyenne du nombre de tentatives nécessaires à chaque partie pour trouver le nombre caché. Tester ce programme et noter les résultats dans un tableau qui indique le nombre de simulations et la moyenne du nombre de tentatives.

Un aperçu des fichiers jupyter proposés en téléchargement.

Le fichier à télécharger ici

Le fichier en docx à télécharger ici

Voici une version procédurale de la recherche des racines d'un trinôme.

from math import *
print("Recherche des racines du trinôme ax²+bx+c=0")
print("Veuillez entrer a, b, c")
a=float(input("a= "))
b=float(input("b= "))
c=float(input("c= "))
delta=b**2-4*a*c
if delta>0 :
	print("Il y a deux racines : ")
	x1=(-b+sqrt(delta))/(2*a)
	x2=(-b-sqrt(delta))/(2*a)
	print("x1 = ",x1)
	print("x2= ",x2)
else :
	if delta==0 :
		print("Il y a une racine :")
		x3=-b/(2*a)
		print(" La racine est : ",x3)
	else :
		print("Il n'y a pas de racine")
	
	

Le but est de transformer ce programme en un ensemble de fonctions.

Le but de l'activité est de réaliser un ensemble de fonctions qui permet de calculer l'aire et le périmètre des figures de base.

Voici un exemple réalisé par des élèves de seconde

# réalisé par des éléves de seconde
# -*- coding: utf-8 -*-

from math import *
from random import *
import matplotlib.pyplot as plt
import numpy as np


def perimetre_carre(c):
    "Renvoie le périmètre d'un carré de côté c"
    assert(c>=0)
    return 4*c

def aire_carre(c):
    "Renvoie l'air d'un carré de coté c"
    return c*c

def peri_rect(l, L):
    "Renvoie le périmètre d'un rectangle de longeur L, et largeur l"
    return (l+2)+(L+2)

def aire_rect(l, L):
    "Renvoie l'air d'un rectangle de longeur L, et largeur l"
    return l * L

def aire_triangle(base, hauteur):
    "Renvoie l'air d'un rectangle quelconque avec une base et une hauteur"
    return (base * hauteur) / 2

def peri_tri_isocelle(h, b):
    "Renvoie le périmètre d'un triangle isocelle avec h comme hauteur, et b comme base"
    return b+2*( sqrt( h**2 + (b/2) ) )

def peri_tri_rectangle(h, b):
    "Renvoie le périmètre d'un triangle rectangle avec h comme hauteur, et b comme base"
    return h + b +(sqrt(h**2 + b**2))

def peri_tri_equilateral(b):
    "Renvoie le périmètre d'un triangle équilatèral avec b comme base"
    return b * 3
def peri_cercle(r):
    "Renvoie le périmètre d'un cercle de rayon r"
    return 2 * pi * r
def aire_cercle(r):
    "Renvoie l'aire d'un cercle de rayon r"
    return pi * r**2

def periFigure():
    return peri_cercle(1)+ peri_cercle(1)
def aireFigure():
    return (aire_cercle(1)*2)+aire_carre(2)

Le but est de construire un ensemble de fonctions de géométrie analytique afin de déterminer la nature de différentes quadrilatères.

Différentes réalisations d'élèves.

from math import *

def milieu(xA,yA,xB,yB):
    xI=(xB+xA)/2
    yI=(yB+yA)/2
    return(xI,yI)


def distance(xA,yA,xB,yB):
    return sqrt((xB-xA)**2+(yA-yB)**2)


def parallélogramme(xA,yA,xB,yB,xC,yC,xD,yD):
    return(milieu(xA,yA,xC,yC)==milieu(xB,yB,xD,yD))



def losange(xA,yA,xB,yB,xC,yC,xD,yD):
    return(parallélogramme(xA,yA,xB,yB,xC,yC,xD,yD)== True and distance(xA,yA,xB,yB)==distance(xC,yC,xB,yB))




def rectangle(xA,yA,xB,yB,xC,yC,xD,yD):
    return(parallélogramme(xA,yA,xB,yB,xC,yC,xD,yD)== True and distance(xA,yA,xC,yC)== distance(xB,yB,xD,yD))


def carré(xA,yA,xB,yB,xC,yC,xD,yD):
    return(rectangle(xA,yA,xB,yB,xC,yC,xD,yD) and losange(xA,yA,xB,yB,xC,yC,xD,yD))

# Créé par GOBILLOTJ, le 10/01/2019 en Python 3.4
from math import*

def d(xa,ya,xb,yb):
    "formule distance dans un repère orthonormé"
    return sqrt((xb-xa)**2+(yb-ya)**2)

def m(xa,ya,xb,yb):
    "formule millieu dans un repère orthonormé"
    return (xa+xb)/2 ,(ya+yb)/2

def p(xa,ya,xb,yb,xc,yc,xd,yd):
    """renvoie true si les coordonées donné
     forment un parallélogramme sinon renvoie false"""
    if m(xa,ya,xc,yc)==m(xb,yb,xd,yd):
        return True
    else: return False
def l(xa,ya,xb,yb,xc,yc,xd,yd):
    """renvoie true si les coordonées donné
     forment un losange sinon renvoie false"""
    return p(xa,ya,xb,yb,xc,yc,xd,yd)==True and d(xa,ya,xb,yb)==d(xa,ya,xd,yd)

def r(xa,ya,xb,yb,xc,yc,xd,yd):
    """renvoie true si les coordonées donné
     forment un rectangle sinon renvoie false"""
    return p(xa,ya,xb,yb,xc,yc,xd,yd)==True and d(xa,ya,xc,yc)==d(xb,yb,xd,yd)

def c(xa,ya,xb,yb,xc,yc,xd,yd):
    """renvoie true si les coordonées donné
     forment un carré sinon renvoie false"""
    return r(xa,ya,xb,yb,xc,yc,xd,yd) and l(xa,ya,xb,yb,xc,yc,xd,yd)