top of page
PROJETS
Projet numero 0 ( personnelle)
- création d'un site avec le logiciel '' wix ''
Projet 1 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source :
vidéo youtube explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
python tri sort et sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
A savoir :
Le naufrage du Titanic a mis fin à la traversée inaugurale du RMS Titanic, un paquebot qui devait relier Southampton à New York. Il se déroule dans la nuit du 14 au 15 avril 1912 dans l' océan Atlantique Nord au large de Terre-Neuve.
Projet 2 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source: video youtube tuto/explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
Projets numero 3:
Alors ,
'' r= [] '' c'est le résultats de l'addition bouléenne de n + p
(screenshot de mon python )
résultats obtenu
( résultats du code python )
(screenshot de mon python )
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
= graphique pas important pour notre recherche
On va donc garder 3 graphiques sur 6
( âge , classes social et sex )
Projet 2 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source: video youtube tuto/explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
Projets numero 3:
Alors ,
'' r= [] '' c'est le résultats de l'addition bouléenne de n + p
(screenshot de mon python )
résultats obtenu
( résultats du code python )
(screenshot de mon python )
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
python tri sort et sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
= graphique pas important pour notre recherche
On va donc garder 3 graphiques sur 6
( âge , classes social et sex )
Projet 2 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source: video youtube tuto/explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
Projets numero 3:
Alors ,
'' r= [] '' c'est le résultats de l'addition bouléenne de n + p
(screenshot de mon python )
résultats obtenu
( résultats du code python )
(screenshot de mon python )
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
python tri sort et sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
= graphique pas important pour notre recherche
On va donc garder 3 graphiques sur 6
( âge , classes social et sex )
Projet 2 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source: video youtube tuto/explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
Projets numero 3:
Alors ,
'' r= [] '' c'est le résultats de l'addition bouléenne de n + p
(screenshot de mon python )
résultats obtenu
( résultats du code python )
(screenshot de mon python )
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
python tri sort et sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
= graphique pas important pour notre recherche
On va donc garder 3 graphiques sur 6
( âge , classes social et sex )
Projet 2 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source: video youtube tuto/explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
Projets numero 3:
Alors ,
'' r= [] '' c'est le résultats de l'addition bouléenne de n + p
(screenshot de mon python )
résultats obtenu
( résultats du code python )
(screenshot de mon python )
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
python tri sort et sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
= graphique pas important pour notre recherche
On va donc garder 3 graphiques sur 6
( âge , classes social et sex )
Projet 2 : notation pix
méthode d'après le cours de NSI :
Etape 1 :
Note = A x Score + B
20 = A x Score-moyen + B
Moyenne-Choisie = A x Score-moyen + B
Etablir une fonction moyenne
Déterminer le score-max ( et score mini )
Stocker le nom des élèves ( scores + notes )
Etape 2
Importer les Scores depuis un fichier CSV , puis tracer un graphique représentant les notes en fonctions des nombres
sur le site www.cours.gratuit j'ai trouver comment faire une note sur 20 :
note1 = float (input
("Entrez la valeur de la note 1 :"))
note2 = float (input("Entrez la valeur de la note 2 :"))
note3 = float (input("Entrez la valeur de la note 3 :"))
note4 = float (input("Entrez la valeur de la note 4 :"))
nb_notes = 4
Moyenne = (note1 + note2 + note3 + note4) / nb_notes
print("la moyenne des notes est : ", Moyenne)
Entrez la valeur de la note 1 :17
Entrez la valeur de la note 2 :16
Entrez la valeur de la note 3 :17
Entrez la valeur de la note 4 :15
la moyenne des notes est : 16.25
>>>
( ceci est un exemple )
ou encore cette possibilités ( source " excel download " )
prendre le mini y affecter 0
prendre le maxi y affecter 20
prendre la moyenne de toutes les notes ----> a (14)
tout ce qui est > à la moyenne --->14 et 20 regle de trois
tous ce qui est inferieur à la moyenne ----> 0 à 14 regle de trois
___________
Donc maintenant passons à l'application de ces informations :
a. Essaions pour une moyenne de classe = à 13/20
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
sachant que ( données à part )
-10/20 = moyenne
- moyenne = niveau 1 toutes rubriques pix
Donc niveau 16/16 rubriques = 10/20
source : video youtube
tuto/explicative
programme python
résultats programme python
b. Comment définir la moyenne ?
Alors :
score = [100,200,500]
def Moyenne(score)
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est"round(moyenne,2))
source: video youtube tuto/explicative
programme python
résultats programme python
c. Comment determiner le score minimum ( source : exemples / exos vu et faits en cours de NSI )
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
programme python
résultats programme python
d. Comment determiner le score maximum ( source : exemples / exos vu et faits aussi en cours de NSI )
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
programme python
résultats programme python
e. Scores et Prénom ( ordre croissant )
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
programme python
résultats programme python
f ( point final ) . Création du graphique des notes sur 20 des élèves de classe de NSI 1ere
le programme :
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
+programme entier
Moyenne_choisie = int(input("Veuillez choisir la moyenne choisie:"))
print(Moyenne_choisie)
score = [100,200,500]
def Moyenne(score):
return sum(score)/ len(score)
moyenne=Moyenne(score)
print("la Moyenne est", round(moyenne,2))
score=[12,232,342,453,653,654,121]
def score_minimum(score):
min=score[0]
for element in score :
if element <= min :
min = element
return min
print(score_minimum(score))
score=[129,20,648]
def score_maximum(score):
max=score[0]
for element in score :
if element >= max :
max = element
return max
print("le score maximum est",score_maximum (score))
score=[149,230,236,243,265,288,301,303,312,371,378,473,480,600]
prénoms="Lila","Salma","Lilou","Alexandre","Joseph","Lilian","Mathis","Maxence","Fantine","Melvyn","Gabin","Léo","Dina","Enzo"
note_20=[6,12,12,12,12,23,23,32,34,42,54,54,94]
for i in range(0,14,1):
x=score[i]
y=note_20[i]
print("Le score",x,"est celui de", prénoms[i],"est correspond a",y,"sur 20")
x=prenom
y=note_sur20
plt.figure("Courbe des notes de pix sur 20 des élèves")
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.ylabel("Prénoms")
plt.show()
Projets numero 3:
Alors ,
'' r= [] '' c'est le résultats de l'addition bouléenne de n + p
(screenshot de mon python )
résultats obtenu
( résultats du code python )
(screenshot de mon python )
PROJET N°4 : LES TRIES
Pour ce projet 4 , je vais vous présenter avec plusieurs captures et explications 5 différents algorithmes de tries ( tri sort , sorted ,par insertion , par selection et enfin le tri à bulle . Nous verrons après comment faire un modèle pour obtenir une belle courbe et affiché les equations dessus
Sort et Sorted
python tri sort et sorted
courbe créer par le programme python de sort et sorted
On part sur une base avec l'algorithme de sort et sorted pour calculer la durée de tries.
Ici on va créer une fonction "création de liste" qui vont faire que dans les listes on va ajouter i qui va prendre les valeurs jusqu'à 1000 puis une boucle va être créée nommée k qui va prendre les valeurs jusqu'à 1000 puis va être rajoutée dans la liste aléatoirement avec des valeur de 0 a 100. Ensuite va se créer des fonctions pour tous les tris donc là c'est le tri sort qui prend en paramètre liste. Puis t1 est affecté à time puis on va trier la liste avec le tri sort, t2 est affecté à time puis on va calculer la durée du temps d'exécution du programme en faisant t1-t2 puis les résultats du tri sort seront ajoutés dans durée et enfin la liste va être mélangée.
Tri par selection
courbe créer par le programme python de sort , sorted et selection
python tri selection
Tri par insertion
python tri insertion
courbe créer par le programme python de sort , sorted et selection et insertion
Tri a bulle
python tri a bulle
courbe créer par le programme python de sort , sorted et selection et insertion et tri a bulle
resultats après executions du tri a bulle
ceci est un programme qui est effectivement une boucle . il va appeller 10x les fonctions ci-dessous
Ce programme ci , va servir à nous tracer une courbe en focntions des résultats précedents des temps de tries . On y a rajouter des titres et légendes pour la fluidité de lecture ( plt.title ) , on va aussi rajouter des couleurs (color=) et des symboles (marker=)
La fonction modèle prend la liste en paramètre ce qui permet de créer des courbes en fonction des abscisses et des ordonnées grâce à la fonction numpy
PROJET N°5 : les K-plus-proche-voisin
programme copier coller de python
# Créé par noah.gregori, le 05/01/2023 en Python 3.7
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,"r"], [1.5,1.5,"t"], [3,3,"r"], [4,4,"t"], [5,5,"t"], [6,6,"r"], [7,7,"r"], [8,8,"t"], [10,10,"r"]]
x = 2
y = 2
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],x,y),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
import math
# Données labélisées et la donnée à classer
positions_classes = [[1,1,1,"r"], [1.5,1.5,1.5,"t"], [3,3,3,"r"], [4,4,4,"t"], [5,5,5,"t"], [6,6,6,"r"], [7,7,7,"r"], [8,8,8,"t"], [10,10,10,"r"]]
x = 2
y = 2
z = 2
def distance (x1 : float, y1 : float, z1 : float, x2 : float, y2 : float, z2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
distances =[]
for element in positions_classes:
distances.append([distance(element[0],element[1],element[2], x,y,z),element[2]])
distances.sort()
#print(distances)
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_t=0
nombre_r=0
for i in range (y):
if distances[i][1] == "t":
nombre_t=nombre_t+1
else :
nombre_r=nombre_r+1
if nombre_t<nombre_r:
return " L'élement est un rectangle "
else:
if nombre_t==nombre_r:
return " Il n'y a pas de solution. "
else:
return " L'élement est un triangle "
print(determiner_classe(distances,k))
resultats des deux programmes , 2D et 3D
EXPLICATIONS 2D :
on va commencer par faire "import math" ce qui va nous servir à faire le carre des valeur des listes
on va ensuite créer une liste positions_classes
on va ensuite attribuer à x et y la valeur de 2
on créer après cela une liste vide distances.sort
programme iris correcte donné par le prof :
( +reponse et graphique )
import pandas
import matplotlib.pyplot as plt
import math
# Données labélisées et la donnée à classer
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur = 2.5
largeur = 0.75
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
'''calcule la valeur absolue de la distance entre les points 1 et 2'''
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 )
distances =[]
for index in range(150):
distances.append([distance(x[index],y[index],longueur,largeur),lab[index]])
distances.sort()
k=3
def determiner_classe(distances_classes : list, y : int) -> str:
nombre_0=0
nombre_1=0
nombre_2=0
for i in range (y):
if distances[i][1] == 0:
nombre_0=nombre_0+1
if distances[i][1] == 1:
nombre_1=nombre_1+1
if distances[i][1] == 2:
nombre_2=nombre_2+1
if nombre_0 > nombre_1 and nombre_0 > nombre_2:
return " La fleur est une setosa "
if nombre_1 > nombre_2 and nombre_1 > nombre_0:
return " La fleur est une versicolor "
if nombre_2 > nombre_1 and nombre_2 > nombre_1:
return " La fleur est une virginica "
print(determiner_classe(distances,k))
plt.axis('equal')
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='versicolor')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='virginica')
plt.scatter(longueur, largeur, color='y', label='à classer')
plt.legend()
plt.show()
graphique quand on execute le programme iris
EXPLICATIONS PROGRAMME IRIS :
reponse : setosa
PROJET N°6 : TITANIC
source google image ,le titanic
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
train = pd.read_csv("titanic_V2.csv", sep = ",")
survived = train[train.Survived == 1]
dead = train[train.Survived == 0]
def plot_hist(feature, bins = 20):
x1 = np.array(dead[feature].dropna())
x2 = np.array(survived[feature].dropna())
plt.hist([x1, x2], label=["Victime", "Survivant"])
plt.legend(loc = "upper left")
plt.title("distribution relative de %s" % feature)
plt.show()
plot_hist("Pclass")
plot_hist("Age")
plot_hist("Fare")
plot_hist("Sex")
plot_hist("Parch")
plot_hist("SibSp")
PROGRAMME TITANIC
GRAPHIQUE DES DONNEES DU TITANIC D'APRES NOTRE PROGRAMME
HYPOTHESES TITANIC :
Les elements que nous auront besoin afin de determiner quel genre de personnes sont le plus susceptibles de survivre ou dans le cas contraire de ne pas survivre c'est :
- l'âge ( enfants , personnes ages )
- le sex ( hommes/femmes
- la classe dans le bateau ( riches / pauvres )
= graphique pas important pour notre recherche
​# Créé par joseph.gregori, le 26/01/2023 en Python 3.7
# ############################################################################
#
# Programme : Puissance 4
# Version : 1
# Date : 26 Janvier 2105
# Interpréteur : Python 3.2
# Environnement de développement : EduPython 2.5.3.0
# Auteur : Noah Juarez
#
# ----------------------------------------------------------------------------
#
# Cette version 1 :
# - demande aux joueurs à tour de role dans quelle colonne il veulent jouer
# - détecte une colonne pleine
# - détecte la grille pleine
# - détecte 4 pions alignés verticalement
# - détecte 4 pions (ou plus) alignés horizontalement
# - détecte 4 pions (ou plus) alignés en diagonale croissante
# - détecte 4 pions (ou plus) alignés en diagonale décroissante
# - filtre la saisie de l'utilisateur et envoie un message sur la sortie standard si la saisie est erronée
#
# ############################################################################
# Structure de donnée mémorisant la grille : une liste à 2 dimensions (6 lignes et 7 colonnes) contenant :
# - un 0 si la case est vide
# - un 1 si un pion ROUGE est dans la case
# - un 2 si un pion BLEU est dans la case
grille=[7*[0], 7*[0], 7*[0], 7*[0], 7*[0], 7*[0]]
""" Repérage des éléments dans la grille :
élément grille[0][0] (coin supérieur gauche) :
[[X, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
élément grille[0][6] (coin supérieur droit) :
[[0, 0, 0, 0, 0, 0, X],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
élément grille[5][0] (coin inférieur gauche) :
[[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[X, 0, 0, 0, 0, 0, 0]]
élément grille[5][6] (coin inférieur droit):
[[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, X]]
"""
# tab_colonne mémorise le nombre de pions dans chacune des colonnes
tab_colonne=7*[0]
# joueur_courant indique le prochain joueur qui doit jouer : 1 pour ROUGE et 2 pour BLEU
joueur_courant=1
# ############################################################################
# La fonction afficher_grille() affiche la grille sur la sortie standard
def afficher_grille():
for i in range(6):
print(grille[i])
# affiche le repère des colonnes sous la grille :
print('\n 0 1 2 3 4 5 6')
# ############################################################################
# La fonction grille_pleine() teste si la grille est pleine (aucun 0 dans la liste grille)
def grille_pleine():
b_plein=True
for i in range(6):
for j in range(7):
if grille[i][j]==0:
b_plein=False
return b_plein
# ############################################################################
# La fonction pions_alignes() teste si 4 pions de même couleur sont alignés dans la grille
def pions_alignes():
trouve=0
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# teste 4 pions alignés horizontalement en alanysant chacune des 6 lignes :
for i in range(6):
rouge=0
bleu=0
for j in range(7):
if grille[i][j]==1:
rouge+=1
bleu=0
if rouge>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge=0
bleu+=1
if bleu>=4:
trouve=2
return trouve
else:
rouge=0
bleu=0
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# teste 4 pions alignés verticalement en alanysant chacune des 7 colonnes :
for j in range(7):
rouge=0
bleu=0
for i in range(6):
if grille[i][j]==1:
rouge+=1
bleu=0
if rouge>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge=0
bleu+=1
if bleu>=4:
trouve=2
return trouve
else:
rouge=0
bleu=0
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# teste les 6 diagonales croissantes :
"""
[0, 0, 0, X, X, X, X]
[0, 0, X, X, X, X, X]
[0, X, X, X, X, X, X]
[X, X, X, X, X, X, 0]
[X, X, X, X, X, 0, 0]
[X, X, X, X, 0, 0, 0]
On part d'une case de départ (D ci-dessous) puis on incrémente les indices en diagonale jusqu'à atteindre l'indice maximal de la grille :
grille[i][j] (i=n° de la ligne de 0 à 5 et j=n° de la colonne de 0 à 6)
j : 0 1 2 3 4 5 6
[0, 0, 0, X, X, X, X] 0
[0, 0, X, X, X, X, X] 1
[0, X, X, X, X, X, X] 2
[D, X, X, X, X, X, 0] 3
[D, X, X, X, X, 0, 0] 4
[D, D, D, D, 0, 0, 0] 5
i
Analyse du problème :
Il y a :
2 diagonales à 4 cases (ij) : 30 21 12 03 et 53 44 35 26
2 diagonales à 5 cases (ij) : 40 31 22 13 04 et 52 43 34 25 16
2 diagonales à 6 cases (ij) : 50 41 32 23 14 05 et 51 42 33 24 15 06
Dans les 6 cas j est croissant (analyse des diagonales de gauche à droite) et i est une fonction de j :
diagonale à 4 cases (ij) 30 21 12 03 : j de 0 à 3 et i=3-j
diagonale à 4 cases (ij) 53 44 35 26 : j de 3 à 6 et i=8-j
diagonale à 5 cases (ij) 40 31 22 13 04 : j de 0 à 4 et i=4-j
diagonale à 5 cases (ij) 52 43 34 25 16 : j de 2 à 6 et i=7-j
diagonale à 6 cases (ij) 50 41 32 23 14 05 : j de 0 à 5 et i=5-j
diagonale à 6 cases (ij) 51 42 33 24 15 06 : j de 1 à 6 et i=6-j
Optimisons : le compteur de base est j, les 3 autres sont fonction de j :
diagonale à 4 cases (ij) 30 21 12 03 : j de 0 à 3 et i=3-j
diagonale à 4 cases (kl) 53 44 35 26 : k=i+2 et l=j+3
diagonale à 5 cases (ij) 40 31 22 13 04 : j de 0 à 4 et i=4-j
diagonale à 5 cases (kl) 52 43 34 25 16 : k=i+1 et l=j+2
diagonale à 6 cases (ij) 50 41 32 23 14 05 : j de 0 à 5 et i=5-j
diagonale à 6 cases (kl) 51 42 33 24 15 06 : k=i et l=j+1
"""
# test des 2 diagonales croissantes à 4 cases :
rouge=[0,0]
bleu=[0,0]
for j in range(4):
i=3-j
k=i+2
l=j+3
# teste la première diagonale [i][j] :
if grille[i][j]==1:
rouge[0]+=1
bleu[0]=0
if rouge[0]>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge[0]=0
bleu[0]+=1
if bleu[0]>=4:
trouve=2
return trouve
else:
rouge[0]=0
bleu[0]=0
# teste la seconde diagonale [k][l] :
if grille[k][l]==1:
rouge[1]+=1
bleu[1]=0
if rouge[1]>=4:
trouve=1
return trouve
elif grille[k][l]==2:
rouge[1]=0
bleu[1]+=1
if bleu[1]>=4:
trouve=2
return trouve
else:
rouge[1]=0
bleu[1]=0
# test des 2 diagonales croissantes à 5 cases :
rouge=[0,0]
bleu=[0,0]
for j in range(5):
i=4-j
k=i+1
l=j+2
# teste la première diagonale [i][j] :
if grille[i][j]==1:
rouge[0]+=1
bleu[0]=0
if rouge[0]>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge[0]=0
bleu[0]+=1
if bleu[0]>=4:
trouve=2
return trouve
else:
rouge[0]=0
bleu[0]=0
# teste la seconde diagonale [k][l] :
if grille[k][l]==1:
rouge[1]+=1
bleu[1]=0
if rouge[1]>=4:
trouve=1
return trouve
elif grille[k][l]==2:
rouge[1]=0
bleu[1]+=1
if bleu[1]>=4:
trouve=2
return trouve
else:
rouge[1]=0
bleu[1]=0
# test des 2 diagonales croissantes à 6 cases :
rouge=[0,0]
bleu=[0,0]
for j in range(6):
i=5-j
k=i
l=j+1
# teste la première diagonale [i][j] :
if grille[i][j]==1:
rouge[0]+=1
bleu[0]=0
if rouge[0]>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge[0]=0
bleu[0]+=1
if bleu[0]>=4:
trouve=2
return trouve
else:
rouge[0]=0
bleu[0]=0
# teste la seconde diagonale [k][l] :
if grille[k][l]==1:
rouge[1]+=1
bleu[1]=0
if rouge[1]>=4:
trouve=1
return trouve
elif grille[k][l]==2:
rouge[1]=0
bleu[1]+=1
if bleu[1]>=4:
trouve=2
return trouve
else:
rouge[1]=0
bleu[1]=0
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# teste les 6 diagonales décroissantes :
"""
grille[i][j] (i=n° de la ligne de 0 à 5 et j=n° de la colonne de 0 à 6)
j : 0 1 2 3 4 5 6
[X, X, X, X, 0, 0, 0] 0
[X, X, X, X, X, 0, 0] 1
[X, X, X, X, X, X, 0] 2
[0, X, X, X, X, X, X] 3
[0, 0, X, X, X, X, X] 4
[0, 0, 0, X, X, X, X] 5
i
Analyse du problème :
Il y a :
2 diagonales décroissantes à 4 cases (ij) : 03 14 25 36 et 20 31 42 53
2 diagonales décroissantes à 5 cases (ij) : 02 13 24 35 46 et 10 21 32 43 54
2 diagonales décroissantes à 6 cases (ij) : 01 12 23 34 45 56 et 00 11 22 33 44 55
Dans les 6 cas j est croissant (analyse des diagonales de gauche à droite) et i est une fonction de j :
diagonale à 4 cases (ij) 03 14 25 36 : j de 3 à 6 et i=j-3
diagonale à 4 cases (ij) 20 31 42 53 : j de 0 à 3 et i=j+2
diagonale à 5 cases (ij) 02 13 24 35 46 : j de 2 à 6 et i=j-2
diagonale à 5 cases (ij) 10 21 32 43 54 : j de 0 à 4 et i=j+1
diagonale à 6 cases (ij) 01 12 23 34 45 56 : j de 1 à 6 et i=j-1
diagonale à 6 cases (ij) 00 11 22 33 44 55 : j de 0 à 5 et i=j
Optimisons : le compteur de base est j, les 3 autres sont fonction de j :
diagonale à 4 cases (ij) 03 14 25 36 : j de 3 à 6 et i=j-3
diagonale à 4 cases (kl) 20 31 42 53 : k=j-1 et l=i
diagonale à 5 cases (ij) 02 13 24 35 46 : j de 2 à 6 et i=j-2
diagonale à 5 cases (kl) 10 21 32 43 54 : k=j-1 et l=i
diagonale à 6 cases (ij) 01 12 23 34 45 56 : j de 1 à 6 et i=j-1
diagonale à 6 cases (kl) 00 11 22 33 44 55 : k=i et l=i
"""
# test des 2 diagonales décroissantes à 4 cases :
rouge=[0,0]
bleu=[0,0]
for j in range(3,7):
i=j-3
k=j-1
l=i
if grille[i][j]==1:
rouge[0]+=1
bleu[0]=0
if rouge[0]>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge[0]=0
bleu[0]+=1
if bleu[0]>=4:
trouve=2
return trouve
else:
rouge[0]=0
bleu[0]=0
if grille[k][l]==1:
rouge[1]+=1
bleu[1]=0
if rouge[1]>=4:
trouve=1
return trouve
elif grille[k][l]==2:
rouge[1]=0
bleu[1]+=1
if bleu[1]>=4:
trouve=2
return trouve
else:
rouge[1]=0
bleu[1]=0
# test des 2 diagonales décroissantes à 5 cases :
rouge=[0,0]
bleu=[0,0]
for j in range(2,7):
i=j-2
k=j-1
l=i
if grille[i][j]==1:
rouge[0]+=1
bleu[0]=0
if rouge[0]>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge[0]=0
bleu[0]+=1
if bleu[0]>=4:
trouve=2
return trouve
else:
rouge[0]=0
bleu[0]=0
if grille[k][l]==1:
rouge[1]+=1
bleu[1]=0
if rouge[1]>=4:
trouve=1
return trouve
elif grille[k][l]==2:
rouge[1]=0
bleu[1]+=1
if bleu[1]>=4:
trouve=2
return trouve
else:
rouge[1]=0
bleu[1]=0
# test des 2 diagonales décroissantes à 6 cases :
rouge=[0,0]
bleu=[0,0]
for j in range(1,7):
i=j-1
k=i
l=i
if grille[i][j]==1:
rouge[0]+=1
bleu[0]=0
if rouge[0]>=4:
trouve=1
return trouve
elif grille[i][j]==2:
rouge[0]=0
bleu[0]+=1
if bleu[0]>=4:
trouve=2
return trouve
else:
rouge[0]=0
bleu[0]=0
if grille[k][l]==1:
rouge[1]+=1
bleu[1]=0
if rouge[1]>=4:
trouve=1
return trouve
elif grille[k][l]==2:
rouge[1]=0
bleu[1]+=1
if bleu[1]>=4:
trouve=2
return trouve
else:
rouge[1]=0
bleu[1]=0
# si on n'a rien trouvé on retourne 0 :
return trouve
# ############################################################################
# La fonction tester_saisie demande au joueur de saisir un nombre entre 0 et 6,
# et réitère la demande tant que la valeur saisie n'est pas un entier dans cet intervale
def tester_saisie(joueur_courant):
if joueur_courant==1:
joueur='ROUGE'
else:
joueur='BLEU'
saisie_correct=False
# gestion des erreurs et filtrage des entrées : demande une saisie jusqu'à ce que la valeur entrée soit un chiffre entre 0 et 6
# Les messages d'erreurs orientant l'utilisateur sont affichés sur la sortie standard (sans provoquer d'erreur)
while not saisie_correct:
s_colonne=input("%s : entrez la colonne où jouer (de 0 à 6) :" % joueur)
# teste si la chaine saise est un entier :
if not s_colonne.isdigit():
print("Erreur de saise : la valeur entrée par le joueur %s n'est pas un nombre entier. Recommencez." % joueur)
# teste si la valeur numérique est comprise entre 0 et 6 :
elif int(s_colonne)<0 or int(s_colonne)>6:
print("Erreur de saise : la valeur numérique entrée par le joueur %s n'est pas comprise entre 0 et 6. Recommencez." % joueur)
else:
saisie_correct=True
# la chaine s_colonne est un chiffre entre 0 et 6 : on la convertit en entier et on la renvoie
return int(s_colonne)
# ############################################################################
# La fonction jouer() demande au joueur courant dans quelle colonne (de 0 à 6) il veut jouer
def jouer(joueur_courant):
if joueur_courant==1:
joueur='ROUGE'
else:
joueur='BLEU'
# La fonction tester_saisie renvoie forcément un chiffre entre 0 et 6 :
colonne=tester_saisie(joueur_courant)
while tab_colonne[colonne]==6:
print('La colonne %d est pleine ! %s jouez dans une colonne non pleine' % (colonne,joueur))
colonne=tester_saisie(joueur_courant)
grille[5-tab_colonne[colonne]][colonne]=joueur_courant
tab_colonne[colonne]+=1
print('\nLe joueur %s vient de jouer dans la colonne %d :' % (joueur,colonne))
# ############################################################################
# P R O G R A M M E P R I N C I P A L
# ############################################################################
print('Le nom des joueurs sera ici ROUGE et BLEU. Le joueur ROUGE commence.')
print('Début de la partie (la grille est vide) :')
gagnant=0
while not grille_pleine() and gagnant==0:
afficher_grille()
jouer(joueur_courant)
joueur_courant=3-joueur_courant
gagnant=pions_alignes()
if gagnant==1:
print('Bravo ! Le joueur ROUGE a gagné !')
elif gagnant==2:
print('Bravo ! Le joueur BLEU a gagné !')
afficher_grille()
if gagnant==0:
print("Fin de la partie : la grille est pleine et il n'y a pas 4 pions alignés")
elif grille_pleine():
print("Fin de la partie : 4 pions sont alignés et la grille est pleine")
else:
print("Fin de la partie : 4 pions sont alignés et la grille n'est pas pleine")
# ############################################################################
# F I N D U P R O G R A M M E
# ############################################################################
On va donc garder 3 graphiques sur 6
( âge , classes social et sex )
bottom of page