BONJOUR
Vous vous trouvez actuellement sur la page Projet, où sont montrés tous les projets que j'ai effectué cette année de première, avec l'aide de mon incroyable prof.
PROJET 2: LES TRIS
Ce projet a été mis au point pour différencier les tris (sort, sorted, fusion, sélection,...) et comparer leur temps d’exécution. Pour cela, voici un programme que j'ai effectué en cherchant des brides ( des bouts de programme) sur internet.
from time import*
import random
import matplotlib.pyplot as plt
import numpy as np
# liste initiale générée aléatoirement :
#On va stocker les résultats de la liste en fonction du tri que l'on a choisi
resultats_sort=[ ]
resultats_sorted=[ ]
resultats_tri_insertion=[ ]
resultats_tri_fusion=[ ]
resultats_tri_selection=[ ]
resultats_tri_bulle=[ ]
resultats_tri_naif=[ ]
n_liste=[ ]
def creation_de_liste():
liste = []
n_liste.append(i*1000)
for k in range(i*1000):
liste.append(random.randint(0,100))
return liste
#Ce morceau de programme va permettre la création d'une liste qui va prendre 1000valeurs de 0 à 100.
# tri par la fonction sort(). La fonction sort est une méthode s'appliquant aux objets de type list. Elle ne peut pas trier un dictionnaire.
def duree_tri_sort(liste):
t1=time()
liste.sort()
t2=time()
duree=t2-t1
resultats_sort.append(duree)
random.shuffle(liste)
#On calcule la durée en soustrayant le 2ème temps avec le1er. Avec append, on va ajouter la liste de résultats à la durée. puis on mélange la liste.
#tri par la fonction sorted. La fonction sorted prend en paramètre d'entrée une liste et retourne en sortie une nouvelle liste, triée en ordre croissant.
def duree_tri_sorted(liste):
t1=time()
liste_triee = sorted(liste)
t2=time()
duree=t2-t1
resultats_sorted.append(duree)
random.shuffle
#on mélange la liste
#tri par insertion. On va placer le plus petit élément à sa place, puis le 2e plus petit élément à sa place, puis le 3e plus petit élément à sa place, etc. La liste se forme sans connaître forcément tout les éléments de la liste. On va prendre les valeurs entre 1 et la longueur de la liste tab.
def tri_insertion(tab):
for i in range(1, len(tab)):
k = tab[i]
j = i-1
while j >= 0 and k < tab[j] :
tab[j + 1] = tab[j]
j -= 1
tab[j + 1] = k
#Calcul de la durée du temps d'execution
def duree_tri_insertion(liste):
t1=time()
tri_insertion(liste)
t2=time()
duree=t2-t1
resultats_tri_insertion.append(duree)
random.shuffle(liste)
#Avec append, on va ajouter la liste de résultats à la durée.
#tri par fusion. On divise en deux moitiés la liste à trier (en prenant par exemple, un élément sur deux pour chacune des listes). On trie chacune d'entre elles. On fusionne les deux moitiés obtenues pour reconstituer la liste triée.
def tri_fusion(tableau):
if len(tableau) <= 1:
return tableau
pivot = len(tableau)//2
tableau1 = tableau[:pivot]
tableau2 = tableau[pivot:]
gauche = tri_fusion(tableau1)
droite = tri_fusion(tableau2)
fusionne = fusion(gauche,droite)
return fusionne
def fusion(tableau1,tableau2):
indice_tableau1 = 0
indice_tableau2 = 0
taille_tableau1 = len(tableau1)
taille_tableau2 = len(tableau2)
tableau_fusionne = []
while indice_tableau1<taille_tableau1 and indice_tableau2<taille_tableau2:
if tableau1[indice_tableau1] < tableau2[indice_tableau2]:
tableau_fusionne.append(tableau1[indice_tableau1])
indice_tableau1 += 1
else:
tableau_fusionne.append(tableau2[indice_tableau2])
indice_tableau2 += 1
while indice_tableau1<taille_tableau1:
tableau_fusionne.append(tableau1[indice_tableau1])
indice_tableau1+=1
while indice_tableau2<taille_tableau2:
tableau_fusionne.append(tableau2[indice_tableau2])
indice_tableau2+=1
return tableau_fusionne
#calcul de la durée du temps d'execution
def duree_tri_fusion(liste):
t1=time()
tri_fusion(liste)
t2=time()
duree=t2-t1
resultats_tri_fusion.append(duree)
random.shuffle(liste)
#tri par selection. On va déterminer le minimum de la liste (le plus petit) et le mettre au début de la liste. On fait la même chose jusqu'à ce que la liste soit trié avec "return".
def tri_selection(liste):
for i in range(len(liste)):
min = i
for j in range(i+1, len(liste)):
if liste[min] > liste[j]:
min = j
tmp = liste[i]
liste[i] = liste[min]
liste[min] = tmp
return liste
#Calcul de la durée du temps d'execution
def duree_tri_selection(liste):
t1=time()
tri_selection(liste)
t2=time()
duree=t2-t1
resultats_tri_selection.append(duree)
random.shuffle(liste)
#tri par bulle. On compare deux à deux les éléments consécutifs d'une liste. On va les permuter (les échanger) lorsque le premier est plus grand que le second tant qu'une permutation est possible.
def tri_bulle(liste):
n = len(liste)
for i in range(n):
for j in range(0, n-i-1):
if liste[j] > liste[j+1] :
liste[j], liste[j+1] = liste[j+1], liste[j]
#Calcul de la durée du temps d'execution
def duree_tri_bulle(liste):
t1=time()
tri_bulle(liste)
t2=time()
duree=t2-t1
resultats_tri_bulle.append(duree)
random.shuffle
#tri naif. On l' appelle ainsi parce qu'il est simples, à défaut d'être efficaces, et se programment en quelques lignes.
def tri_naif(L):
R = []
while len(L) > 0:
m = L[0]
for i in range(1,len(L)):
if L[i] < m:
m = L[i]
R += [ m ]
L.pop( L.index(m) )
return R
#Calcul de la durée du temps d'execution
def duree_tri_naif(liste):
t1=time()
tri_naif(liste)
t2=time()
duree=t2-t1
resultats_tri_naif.append(duree)
random.shuffle
#Sur le graphique, on prendra 10 points pour représenter la courbe pour chacun des tris.
for i in range(1,11):
print(i)
L= creation_de_liste()
duree_tri_sort(L)
duree_tri_sorted(L)
duree_tri_insertion(L)
duree_tri_fusion(L)
duree_tri_selection(L)
duree_tri_bulle(L)
duree_tri_naif(L)
# Programme pour tracer la figure et avoir les différents tris comparé entre eux.
def tracer_figure(nliste, liste_sort, liste_sorted, liste_tri_insertion, liste_tri_fusion, liste_tri_selection, liste_tri_bulle, liste_tri_naif):
plt.figure(figsize = (16, 10))
plt.plot(nliste, liste_sort, "o", color='green', label='sort', marker='+')
plt.plot(nliste, liste_sorted, "o", color='orange', label='sorted', marker='x')
plt.plot(nliste, liste_tri_insertion, "o", color='red', label='tri_insertion', marker='8')
plt.plot(nliste, liste_tri_fusion, "o", color='purple', label='tri_fusion', marker='*')
plt.plot(nliste, liste_tri_selection, "o", color='black', label='tri_selection', marker='+')
plt.plot(nliste, liste_tri_bulle, "o", color='blue', label='tri_bulle', marker='x')
plt.plot(nliste, liste_tri_naif, "o", color='green', label='tri_naif', marker='*')
plt.xlabel('n')
plt.ylabel('Durée')
plt.title("Durée versus n")
plt.legend()
plt.grid(True)
plt.show()
#On peut donner une couleur aux différentes courbes de tris ainsi qu'un nom et un label, en mettant plot() avant.
tracer_figure(n_liste, resultats_sort, resultats_sorted, resultats_tri_insertion, resultats_tri_fusion, resultats_tri_selection, resultats_tri_bulle, resultats_tri_naif)
#Attention, l'orthographe des mots est très importante, le programme ne s’exécutera pas pour une petite erreur (ne pas oublier de mettre un r à marker par exemple). il arrive quelques fois qu'une erreur reste introuvable, dans ce cas, il faut lire ce qui est marqué en rouge dans la console.
conclusion:
Après l’exécution du programme, un graphique apparait avec les différentes courbes de tris.
On remarque que le tri sort, sorted et le tri fusion sont les plus rapides.
Le tri le plus long est le tri à bulle. En effet, ce tri doit effectuer beaucoup de comparaison et de déplacement donc le temps d’exécution est long.
Voici l'ordre des tris du plus long au plus rapide:
tri à bulle>tri insertion>tri sélection>tri naïf>sorted, sort, fusion.
Les tris sort, sorted et fusion sont tellement rapides par rapport aux autres tris que l'on pourrait penser que leur temps d'éxecution est à 0, sauf que ce n'est pas le cas.
Projet 1
convertir en note sur 20 un score pix
nom_eleve = ["alexandre","lucie", "fantine"] #creation de 3listes
score_eleve = [310,250,481]
note_eleve = []
score_moyen = 0 #le score moyen va étre affecté à 0
score_max = max(score_eleve) #on va chercher le score max dans la liste score_eleve
for i in score_eleve: #création d'une boucle for pour aller chercher chacune des valeurs
score_moyen += i/len(score_eleve)
moyenne_choisie = 13 #on a choisit la moyenne, ici c'est 13
a = (moyenne_choisie-20)/(score_moyen-score_max)
b = 20-((moyenne_choisie-20)/(score_moyen-score_max))*score_max
for i in score_eleve: #création d'une boucle pour afficher le score
score = a *i + b
score = round(score, 2)
note_eleve.append(score)
print(score)
print("nom :", nom_eleve) #on va demander à python d'afficher dans la console le nom
print("score :", score_eleve) des élèves, leur score et leur note.
print("note :", note_eleve)
PROJET 3: k plus proche voisin
On cherche à déterminer quelle est la variété d'une fleur avec une largeur et une longueur aléatoire.
import pandas
import matplotlib.pyplot as plt
import math #permet de faire la racine carrée avec math.sqrt
iris=pandas.read_csv("iris.csv")
x=iris.loc[:,"petal_length"]
y=iris.loc[:,"petal_width"]
lab=iris.loc[:,"species"]
longueur=2.5 #attention, ne pas mettre des virgules à la place des points
largeur=0.75 #En python, les virgules sont remplacées par des points.
k=3
def distance (x1 : float, y1 : float, x2 : float, y2 : float ) -> float :
return math.sqrt( (x2 - x1)**2 + (y2 - y1)**2 ) #permet de faire la racine carré
distances =[]
for index in range(150): #il y a 150 lignes dans le dossier iris.
distances.append([distance(x[index], y[index], longueur, largeur),lab[index]])
distances.sort()
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 "l'élément est un setosa"
if nombre_1>nombre_0 and nombre_1<nombre_2:
return "l'élément est un verginica"
if nombre_2>nombre_0 and nombre_2>nombre_1:
return "l'élément est un versicolor"
print(determiner_classe(distances,k))
plt.scatter(x[lab == 0], y[lab == 0], color='g', label='setosa')
plt.scatter(x[lab == 1], y[lab == 1], color='r', label='virginica')
plt.scatter(x[lab == 2], y[lab == 2], color='b', label='versicolor')
plt.scatter(longueur, largeur, color='k')
plt.show()
plt.legend #permet d'afficher le graphique.
PROJET TITANIC
on cherche à déterminer quels sont les conditions qui permettent la survie de certaines personnes à bord du Titanic. Pour cela, voici un programme qui va répondre à nos questions:
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")
le graphique Pclass présente les 3 classes en fonction de la richesse. Les riches sont en classe 1 et les pauvres en classe 3. On remarque que dans la 1ere classe, le taux de survivant est plus élevé que le taux de victime alors qu'en classe 3, le taux de survivant est beaucoup plus inférieur que le taux de victimes.
conclusion: les riches ont plus de chances de survivre que les pauvres.
Le graphique distribution relative de l'age montre que les enfants âgés de moins de 10 ans ont un taux de survie plus élevé que le taux de victime. mais les personnes âgés entre 20 et 30 ans ont un taux de victime beaucoup plus élevé.
conclusion: les personnes de 20ans sont ceux qui apportent le plus de victimes.
Le graphique sexe montre que les femmes (1er colonne) ont un taux de survie plus élevé que celui de l'homme (2eme colonne). Les hommes ne survivent presque pas, il y a seulement 100 survivants et environ 500 morts.
conclusion: les femmes sont prioritaires pour monter dans les barques, elles ont donc plus de chances de survivre.
Le graphique SibSp montre que lorsque l'on a pas de frère ou de sœur, on a moins de chance de survie, alors que si on a au moins 1 frère ou 1 sœur, le taux de survie augmente.
conclusion: les passagers du Titanic ont besoin de s'entraider pour augmenter leur chance de survie.
Projet final: Le sudoku
Je souhaiterai développer un programme python pour faire un sudoku. L'utilisateur pourra rentrer des valeurs afin de résoudre le sudoku et à la fin, la solution sera mise.
Le principe du sudoku est très simple: il faut remplir le tableau en ne mettant pas le même chiffre dans une case, sur une même ligne et idem pour la colonne.
Voila un exemple d'une grille de sudoku lorsque tous les chiffres ne sont pas encore rentrés.
Et voici un exemple d'une grille de sudoku résolue. On peut voir qu'il n'y a pas le même chiffre dans une même colonne ni dans une même ligne. Idem pour les cases.
Séance n°1 : 26/01/2023
Je me suis demandé si tous les sudoku, même ceux qui sont aléatoires pouvaient être résolus. j'ai utilisé la fonction import random au début pour renvoyer des nombres aléatoires et j'ai crée une liste où j'ai mis les chiffres de 1 à 9.
Séance n°2 : 30/01/2023
Aujourd'hui, j'ai effectué des recherches pour savoir comment afficher une grille de sudoku.
Pour afficher une grille 10x10 on va créer des widgets. Un widget est une extension d'application. On peut personnaliser le widget et le placer sur l'écran d'accueil pour que l'on puisse ouvrir rapidement l'application.
Séance n°3 : abs
Séance n°4 : 02/02/2023
Pour commencer, je vais faire une liste de liste pour une grille 2x2, et je vais y mettre les coordonnées des points. par exemple, [[1,1],[1,2],[2,1],[2,2]].
je vais ensuite faire une boucle pour que le programme trouve lui même les coordonnées.
J'ai rencontré un problème avec ma liste de liste parce qu'il fallait faire 2boucles ce qui est inutile. on a donc remplacé la liste de liste par une liste vide et les coordonnées ont été affichées par la console.
Voilà le début du programme:
import random
chiffres = [1,2,3,4,5,6,7,8,9]
coordonnees = [] #liste vide où on va insérer les coordonnées.
for x in range(1,10):
for y in range(1,10):
coordonnees.append([x,y]) #on va ajouter x et y, pour pouvoir ensuite afficher les coordonnés dans la console.
print(coordonnees)
>>>
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [1, 9], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [2, 9], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [3, 9], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [4, 8], [4, 9], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [5, 8], [5, 9], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [6, 8], [6, 9], [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7], [7, 8], [7, 9], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 6], [8, 7], [8, 8], [8, 9], [9, 1], [9, 2], [9, 3], [9, 4], [9, 5], [9, 6], [9, 7], [9, 8], [9, 9]]
J'ai cherché des informations sur internet pour savoir comment afficher une grille de sudoku.
On peut utiliser from tkinter import * au début du programme.
tkinter est une bibliothèque graphique qui permet la création d'interfaces graphiques.
Séance n°5: 20/02/2023
Je n'ai pas réussi à afficher le graphique donc je laisse ça de coté pour l'instant et j'ai réfléchi à comment je pouvais rentrer des chiffres dans les coordonnées. Je pense que je peux régler cette question avec un dictionnaire en mettant les coordonnées en clés et les chiffres en valeurs. Je vais surement avoir besoin de la fonction append.
Séance n°6: 23/02/2023
voici mon début de programme:
import random
from tkinter import *
chiffres = [1,2,3,4,5,6,7,8,9]
coordonnees = []
for x in range(1,10):
for y in range(1,10):
coordonnees.append([x,y,0]) #J'ai rajouté un 0 aux coordonnées pour ensuite
print(coordonnees) modifier ce chiffre et rentrer une autre valeur.
#coordonnée_du_joueur = input("coordonnées: ")
"""
if coordonnée_du_joueur !=
print(coordonnée_du_joueur)
"""
resultat=int(input("coordonnees "))
valeur_abscisse= int(input("rentrez une valeur pour abscisse"))
valeur_ordonnee= int(input("rentrez une valeur pour ordonnée"))
nombre_choisi= int(input("rentrez une valeur"))
#Les input permettent à l'utilisateur de rentrer des valeurs.
J'ai rajouté des int pour que l'utilisateur rentre seulement des entiers.
Il faut que je mette une limite à nombre_choisi pour que l'utilisateur rentre seulement les chiffres de 1à 9.
#J'ai changé le programme en créant une fonction:
liste_abscisse = [1,2,3,4,5,6,7,8,9]
def abscisse():
a = int(input("valeur : ")) #cette fonction permet de savoir si une
for i in range(0, len(liste_abscisse)): valeur choisi par l'utilisateur pour les
if a in liste_abscisse[i]: abscisses fait parti des coordonnées.
return a
return abscisse()
valeur_abscisse = abscisse()
print(valeur_abscisse)
Je suis confrontée à un problème: Lorsque l'utilisateur rentre une lettre, Python affiche du rouge dans la console. J'aimerais que lorsque l'utilisateur rentre une valeur qui n'est pas un entier, le programme repose la question au lieu d'afficher une erreur.
seance n°7: 27/02/2023
import random
from tkinter import *
chiffres = [1,2,3,4,5,6,7,8,9]
coordonnees = []
for x in range(1,10):
for y in range(1,10):
coordonnees.append([x,y,0])
print(coordonnees)
liste_abscisse = [1,2,3,4,5,6,7,8,9]
def abscisse():
a = int(input("valeur abscisse : "))
for i in liste_abscisse:
if a == i:
return a
return abscisse()
valeur_abscisse = abscisse()
print(valeur_abscisse)
liste_ordonnee = [1,2,3,4,5,6,7,8,9]
def ordonnee():
a = int(input("valeur ordonnee : "))
for i in liste_ordonnee:
if a == i:
return a
return ordonnee()
valeur_ordonnee = ordonnee()
print(valeur_ordonnee)
Voici mon début de programme:
import random #génère aléatoirement
from tkinter import * #importe le module Tkinter
fenetre = Tk()
coordonnees = [] # Liste vide
for x in range(1,10): # Pour x et y qui sont compris entre 1 et 10
for y in range(1,10):
coordonnees.append([x,y,0]) # Boucle pour remplir la liste vide des coordonnées
print(coordonnees) # Afficher les coordonnées dans la console
print(coordonnees[1][2]) # Afficher le 3eme élément de la 2eme sous-liste
"""lignes = (1,2,3,4,5,6,7,8,9)
colonnes = (1,2,3,4,5,6,7,8,9)
cases = (1,2,3,4,5,6,7,8,9)"""
liste_abscisse = [1,2,3,4,5,6,7,8,9] #Création d'une liste pour les abscisses
def abscisse(): # Création d'une fonction abscisse
a = int(input("valeur abscisse : ")) # Demande à l'utilisateur de choisir une valeur pour les abscisses
for i in liste_abscisse: # Pour une valeur i qui se trouve dans la liste des abscisses
if a == i: # Si a est égale à i
return a # Renvoyer a
return abscisse() # Sinon renvoyer la fonction abscisse
valeur_abscisse = abscisse()
#print(valeur_abscisse)
#Entrée: liste non vide d'entiers
#Sortie: nombre choisi par l'utilisateur
liste_ordonnee = [1,2,3,4,5,6,7,8,9]
def ordonnee():
a = int(input("valeur ordonnee : ")) #demande à l'utilisateur de choisir une valeur pour les ordonnées
for i in liste_ordonnee:
if a == i:
return a
return ordonnee()
valeur_ordonnee = ordonnee()
#print(valeur_ordonnee)
#Entrée: liste non vide d'entiers
#Sortie: nombre choisi par l'utilisateur
chiffres = [1,2,3,4,5,6,7,8,9] #création d'une liste de chiffres qui va de 1 à 9
def remplir_grille():
a = int(input("choisissez un chiffre : ")) #demande à l'utilisateur de choisir un chiffre entre 1 et 9
if a in chiffres:
return a
else:
return remplir_grille()
valeur_grille = remplir_grille()
#print(valeur_grille)
liste_de_valeur=[1,0,0,0,0,0,0,0,6,0,0,6,0,2,0,7,0,0,7,8,9,4,5,0,1,0,3,0,0,0,8,0,7,0,0,4,0,0,0,0,3,0,0,0,0,0,9, 0,0,0,4,2,0,1,3,1,2,9,7,0,0,4,0,0,4,0,0,1,2,0,7,8,9,0,8,0,0,0,0,0,0]
for i in range(0, 80): # Liste de valeurs d'un sudoku pas totalement rempli, les 0 sont les valeurs à trouver
coordonnees[i][2] = liste_de_valeur[i]
#i prend des valeurs de 0 à 80
test = 0
for ligne in range(1, 10): #création d'une boucle pour ligne qui va de 1 à 10
print(ligne)
print("ff",coordonnees[ligne][2])
for colonne in range(1, 10): #création d'une boucle pour colonne qui va de 1 à 10
Button(fenetre, text='%s' % (coordonnees[test][2]), borderwidth=30).grid(row=ligne, column=colonne)
test += 1
#Button(fenetre, text='O%s-A%s' % (ligne,colonne), borderwidth=10).grid(row=ligne, column=colonne)
'''
Button(fenetre, text='O1-A1', borderwidth=1).grid(row=1, column=1)
Button(fenetre, text='O1-A2', borderwidth=1).grid(row=1, column=2)
Button(fenetre, text='O2-A3', borderwidth=1).grid(row=2, column=3)
Button(fenetre, text='O2-A4', borderwidth=1).grid(row=2, column=4)
Button(fenetre, text='O3-A3', borderwidth=1).grid(row=3, column=3)'''
fenetre.mainloop() #permet d'ouvrir la fenêtre et d'afficher la grille
'''
label = Label(fenetre, text="Jeu de Sudoku")
label.pack() #afficher texte
bouton = Checkbutton(fenetre, text="supprimer?")
bouton.pack()
s = Spinbox(fenetre, from_=0, to=10)
s.pack()
fenetre.mainloop()'''