initialisation python

autre_entrain.py

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))

maininit.py

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)

    

    

moduleinit.py

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) 
##
##

tpGPS.py

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