Created
February 11, 2018 22:22
-
-
Save BENALI31/c502947e9e37eaaed86bf4768e8d2775 to your computer and use it in GitHub Desktop.
initialisation python
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import statistics | |
# Use: statistics.mean(liste) | |
from statistics import mean | |
# Use: mean(liste) | |
from operator import attrgetter | |
import csv | |
import operator | |
temps = 6.892 | |
distance = 19.7 | |
v=distance / temps | |
print ("cest le temps ",(temps)) | |
print ("cest le temps ",(distance)) | |
print ("apres arondisement" ) | |
# cest pour arondir le chifre v avec 2 ou 5 chifres apres la vergule | |
v=round(v,2) | |
print (v) | |
T= range(0,5) | |
for i in T: | |
print(T[i]) | |
print ("le minimum de la liste ") | |
print (min(T)) | |
print ("le max de la liste ") | |
print (max(T)) | |
print ("le moyenne de la liste ") | |
# il faut importer la bibliotheque | |
print (mean(T)) | |
l = [555,854,6,84,98,45,214,763,11,13] | |
#cest pour reorganiser les valeurs dans la liste | |
l.sort() | |
print(l) | |
print(l[2]) | |
print(len(l)) | |
facto=input("veullez saisir un nombre ") | |
print("vous avez saisie",facto) | |
# Fonction factorielle | |
def fact(x) : | |
x=int(x) | |
result = 1 | |
while (x>1) : | |
result=result*x | |
x=x-1 | |
return result | |
print("la factorielle de ",facto," est" ,fact(facto)) | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from module import triSelection | |
from module import tri_rapide | |
from module import tri_insertion | |
from module import fusion | |
from module import tri_fusion | |
#from module import tri_rapideprof | |
import random | |
import time | |
T=[55,5,6,65,78,52,32,95,6432,652,99,41,21,14,35] | |
print(T) | |
print("") | |
print ("------------tri par selection ------------------------- ") | |
triSelection(T) | |
print(T) | |
print("") | |
print("") | |
T1=[] | |
for i in range(21): | |
T1.append( random.randint(0, 100) ) | |
print ("-------------------avant le tri------------------- ") | |
print(T1) | |
print("") | |
print ("------------- apres le tri rapide------------------------------ ") | |
tri_rapide(T1) | |
print(T1) | |
print ("------------------liste aleatoire incertion------------------ ") | |
#generer une liste aleatoire | |
L = [] | |
for i in range(21): | |
L.append( random.randint(0, 100) ) | |
print(L) | |
print (" ") | |
print ("------------------apres le tri par incertion---------------- ") | |
tri_insertion(L) | |
print(L) | |
print (" ") | |
print ("-----------------exo fusion------------------ ") | |
k = [] | |
for i in range(21): | |
k.append( random.randint(0, 100) ) | |
print(k) | |
print (" ") | |
print ("------------------apres le tri par fusion----------- ") | |
tri_fusion(k) | |
#fusion(tri_fusion(k[0:(len(L)//2)]),tri_fusion(k[(len(L)//2):])) | |
#tri_fusion(m) | |
print(k) | |
print("test de puissance ") | |
fx=5**3 | |
print(fx) | |
##mo = [] | |
## | |
##print (" ") | |
##print ("------------------creation de liste ----------- ") | |
## | |
##mo.append( random.randint(0, 100) ) | |
##print(mo) | |
##tri_rapideprof(mo) | |
##print ("------------------apres le tri du prof----------- ") | |
##print(mo) | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
def triSelection(tableau): | |
nb = len(tableau) | |
for en_cours in range(0,nb): | |
plus_petit = en_cours | |
for j in range(en_cours+1,nb) : | |
if tableau[j] < tableau[plus_petit] : | |
plus_petit = j | |
if min is not en_cours : | |
temp = tableau[en_cours] | |
tableau[en_cours] = tableau[plus_petit] | |
tableau[plus_petit] = temp | |
def tri_insertion(tableau): | |
for i in range(1,len(tableau)): | |
en_cours = tableau[i] | |
j = i | |
#décalage des éléments du tableau } | |
while j>0 and tableau[j-1]>en_cours: | |
tableau[j]=tableau[j-1] | |
j = j-1 | |
#on insère l'élément à sa place | |
tableau[j]=en_cours | |
#################################################################################### | |
##################################################################################### | |
def tri_rapide(L): | |
# """trirapide(L): tri rapide (quicksort) de la liste L""" | |
def trirap(L, g, d): | |
pivot = L[(g+d)//2] | |
i = g | |
j = d | |
while True: | |
while L[i]<pivot: | |
i+=1 | |
while L[j]>pivot: | |
j-=1 | |
if i>j: | |
break | |
if i<j: | |
L[i], L[j] = L[j], L[i] | |
i+=1 | |
j-=1 | |
if g<j: | |
trirap(L,g,j) | |
if i<d: | |
trirap(L,i,d) | |
g=0 | |
d=len(L)-1 | |
trirap(L,g,d) | |
def fusion(Liste_gauche,Liste_droite): | |
resultat = [] #inatiation de la liste resultat | |
index_gauche, index_droite = 0, 0 | |
while index_gauche < len(Liste_gauche) and index_droite < len(Liste_droite): | |
if Liste_gauche[index_gauche] <= Liste_droite[index_droite]: | |
resultat.append(Liste_gauche[index_gauche]) | |
index_gauche += 1 | |
else: | |
resultat.append(Liste_droite[index_droite]) | |
index_droite += 1 | |
if Liste_gauche: | |
resultat.extend(Liste_gauche[index_gauche:]) | |
if Liste_droite: | |
resultat.extend(Liste_droite[index_droite:]) | |
L=resultat | |
return L | |
def tri_fusion(L): | |
if len(L) <= 1: | |
return L | |
milieu = len(L) // 2 | |
#decoupe de la liste L en deux sous liste Liste_gauche et Liste_droite | |
Liste_gauche = L[:milieu] | |
Liste_droite = L[milieu:] | |
Liste_gauche = tri_fusion(Liste_gauche)# la même chose pour Liste_gauche | |
Liste_droite = tri_fusion(Liste_droite)# la même chose pour Liste_droite | |
return fusion(Liste_gauche, Liste_droite) #fusionner Liste_gauche et Liste_droite | |
## | |
##def tri_rapideprof(L): | |
## if not L: # condition d'arrêt dans la fonction récursive si L est vide | |
## return [] | |
## else: | |
## pivot = L[-1] # choix du dernier élément de la liste comme pivot, nous prenons un cas simple | |
## | |
## sous_liste_gauche = [x for x in L if x < pivot] # construction de la première sous liste (liste gauche) ,tous les éléments de la sous liste gauche est inférieur au pivot sous_liste_droite = [x for x in L[:-1] if x >= pivot]# construction de la deuxième sous liste (liste droite), tous les éléments de la sous liste droite est supérieure au pivot | |
## | |
## return tri_rapide(sous_liste_gauche) + [pivot] + tri_rapide(sous_liste_droite) | |
## | |
## |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from math import sqrt,pow | |
#from operator import attrgetter | |
from operator import itemgetter | |
from module import triSelection | |
import os | |
os.chdir("C:/Users/bonj/Desktop/python/tp44") | |
print("reponse de tp4") | |
print("") | |
print("a la taille de la base de donee") | |
print("") | |
print("je considere int = 4 oct") | |
print("") | |
print("je considere charactere = 2 oct") | |
print("") | |
print("(16+8+8)*1000000= 24 000 000") | |
print("") | |
print("la largeur est 10 000 m") | |
print("") | |
print("pour couvrir entierement le plan il faut 100 000 point d interet ") | |
# la fonction prend en entrée un fichier (dbFileName) de base de données | |
# la fonction retourne la liste globale lg contenant les points d'intéret de la base et le nombre (np) de points trouvés | |
def readDB(dbFileName): | |
# on utilise le mot-clé with open pour ouvrir le fichier et fermer apres utilisation | |
with open(dbFileName) as f: | |
pois = f.readlines()# elle stock les lignes dans une liste appeler pois | |
np = len(pois) #le nombre de case de la liste qui presente le nombre de ligne | |
lg = [None]*np | |
for ind in range(np): | |
poi = pois[ind] | |
proprietes = poi.split("|") | |
#affectation des fraquement de lignes au tuple de proprieté | |
categorie = str( proprietes[0] ) | |
x = int( proprietes[1] ) | |
y = int( proprietes[2] ) | |
lg[ind] = [categorie, x, y] | |
return lg,np # retourne | |
result=readDB("point_dinteret.txt") | |
print("") | |
print("apres l^ppel de la fonction ") | |
listglob=result[0] # cest pour affecter les resultats lg retourner par la fonction readatabase | |
print(listglob[0],"gggggggg") # jaffiche le pmremier point dinteret stocke dans ma liste | |
print(result[1]) | |
print(listglob[0][2]) | |
print("vddqbb 2222") | |
print("") | |
# je cherche le point dinteret le plus proche | |
def getDistance(ma_posi_xx,ma_posi_yy,xlist,yliste): | |
distance=((ma_posi_xx-xlist)**2)+((ma_posi_yy-yliste)**2) | |
distance=sqrt(distance) | |
return distance # retourne la distance entre les deux points | |
################################################################################################################## | |
# la fonction qui nous retourne le point le plus proche | |
def getPoiClosest(tab,ma_posi_xx,ma_posi_yy): | |
# je parcour mon tableau de tuples de point dinteret | |
for ind in range(len(tab)): | |
#j'affecte chaque partie du tuple a un tableau tab | |
tab_tuple = tab[ind] | |
categorie = tab_tuple[0] | |
x = tab_tuple[1] | |
y = tab_tuple[2] | |
distance=getDistance(ma_posi_xx,ma_posi_yy,x,y) | |
# pour une meilleur lisibilité je fait un arondissement de 4 chiffres | |
distance=round(distance,4) | |
# j'affecte la distance a mon tableau de tuples et pour une bonne lisibilite je rajoute "la distance est" dans le tuple | |
tab[ind] = [categorie, x, y,"la distance est",distance] | |
tab.sort(key=itemgetter(4)) | |
return (tab[0]) #je retourne le point le plus pret | |
######################################################################################################################## | |
point_pret=getPoiClosest(listglob,216,84) # teste de ma fonction | |
print(point_pret) | |
######################################################################################################################## | |
def getPoiInRange(tab,ma_posi_xx,ma_posi_yy, threshold): | |
tab1=[] | |
indi_tab1= -1 | |
# je parcour mon tableau de tuples de point dinteret | |
for ind in range(len(tab)): | |
#j'affecte chaque partie du tuple a un tableau tab | |
tab_tuple = tab[ind] | |
categorie = tab_tuple[0] | |
x = tab_tuple[1] | |
y = tab_tuple[2] | |
distance=getDistance(ma_posi_xx,ma_posi_yy,x,y) | |
# pour une meilleur lisibilité je fait un arondissement de 4 chiffres | |
distance=round(distance,4) | |
if distance<= threshold : | |
indi_tab1= +1 | |
# j'affecte la distance a mon tableau de tuples et pour une bonne lisibilite je rajoute "la distance est" dans le tuple | |
tab1.append([categorie, x, y,"la distance est",distance]) | |
# je trie mon nouveau tableau qui respect le rayon de distance | |
tab1.sort(key=itemgetter(4)) | |
return tab1 | |
################################################################################################ | |
# je teste ma fonction | |
# passage de parametre (listeglobale des points dinterets ,X,Y,rayon) | |
ss=getPoiInRange(listglob,555,33, 50) | |
#la boucle pour afficher tout mes point a linterieur du rayon | |
for ind in range(10): | |
print(ss[ind]) | |
####################################################################################################### | |
def sort (tab,ma_posi_xx,ma_posi_yy): | |
# je parcour mon tableau de tuples de point dinteret | |
for ind in range(len(tab)): | |
#j'affecte chaque partie du tuple a un tableau tab | |
tab_tuple = tab[ind] | |
categorie = tab_tuple[0] | |
x = tab_tuple[1] | |
y = tab_tuple[2] | |
distance=getDistance(ma_posi_xx,ma_posi_yy,x,y) | |
# pour une meilleur lisibilité je fait un arondissement de 4 chiffres | |
distance=round(distance,4) | |
# j'affecte la distance a mon tableau de tuples et pour une bonne lisibilite je rajoute "la distance est" dans le tuple | |
tab[ind] = [categorie, x, y,"la distance est",distance] | |
gh=triSelection(tab) | |
return (gh) #je retourne tout les point les point le plus pret dans lordre croissant | |
###################################################################################################################### | |
## | |
def triSelection(tableau): | |
nb = len(tableau) | |
for en_cours in range(0,nb): | |
plus_petit = en_cours | |
for j in range(en_cours+1,nb) : | |
if tableau[j][4] < tableau[plus_petit][4] : | |
plus_petit = j | |
if min is not en_cours : | |
temp = tableau[en_cours] | |
tableau[en_cours] = tableau[plus_petit] | |
tableau[plus_petit] = temp | |
return (tableau) | |
################################################################################################################## | |
# test de la fonction sort | |
print(" teste de la fonction sort !!!!!! il faut laisser le temps de traitement !!!! juste 4 valeur si non vous lancez la boucle en commentaire ") | |
tr=sort (listglob,555,33) | |
print(tr[0]) | |
print(tr[1]) | |
print(tr[2]) | |
print(tr[3]) | |
print(tr[4]) | |
#la boucle pour afficher tout mes point les plus proches pour tester tout les points dans lordre croissant | |
"""for ind in range(10): | |
print(ss[ind]) | |
""" | |
####################################################################################### | |
#a suivre | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment