Demo entry 6313903

School work

   

Submitted by anonymous on Oct 26, 2016 at 14:43
Language: Python 3. Code size: 5.3 kB.

# -*- coding: utf-8 -*-
"""
NOM Prénom
DM n°3 d'informatique
Exercice 1 : Coordonnées GPS
"""

############################################################################

import math as m  # Import du module math qui contient les f° asin, cos, ...

############################################################################



def distance(lat1,long1,lat2,long2):
    """
        Renvoie la distance entre deux points dont les coor
    """
    lat1, long1 = m.radians(lat1), m.radians(long1)
    lat2, long2 = m.radians(lat2), m.radians(long2)
    return 6371*1000*m.acos(m.sin(lat1)*m.sin(lat2)\
        +m.cos(lat1)*m.cos(lat2)*m.cos(long1-long2))

def longueur(liste_latitudes,liste_longitudes):
    """
        Fonction renvoyant la longueur totale du parcours défini par les points
        dont les latitudes et longitudes sont contenues dans les listes passées
        en argument.
    """
    # On vérifie que les arguments respectent les conditions nécessaires pour
    # pouvoir calculer la longueur du parcours.
    assert (isinstance(liste_latitudes,  list)\
        and isinstance(liste_longitudes, list)\
        and len(liste_longitudes) >= 2\
        and len(liste_longitudes) == len(liste_latitudes)),\
        print("Les paramètres doivent être deux listes de même longueur au "+\
              "moins égale à 2")

    longueur_provisiore = 0 # Variable contenant la longueur provisoire
    for i in range(1,len(liste_longitudes)):
        longueur_provisiore += distance(liste_latitudes[i-1],\
            liste_longitudes[i-1], liste_latitudes[i], liste_longitudes[i])
    return longueur_provisiore

def lecture_fichier():
    """Fonction qui ne prend aucun argument et qui retourne le tuple 
    formé par la liste des instants, la liste des latitudes et la liste des 
    longitudes des relevés contenus dans le fichier D:\CoordGPS.txt"""
    fichier = open("./CoordGPS.txt","r") # Penser au Double \\ 
    # Si le fichier se trouve dans un autre répertoire que D:\, il faut
    # modifier en conséquence la ligne ci-dessus.
    fichier.readline() # On se débarrasse de la 1ère ligne en la lisant
    liste_temps = []   # Initialisation de la liste des temps
    liste_lat = []     # Initialisation de la liste des latitudes
    liste_long = []    # Initialisation de la liste des longitudes
    for ligne in fichier:    # Itération sur les lignes du fichier
        # ligne est une chaine du type "72;48.57290290;7.77515036\n"
        liste = ligne.split(";")  
        # liste est une liste du type ["72","48.57290290","7.77515036\n"]
        temps = int(liste[0])        # Récupération de l'instant
        lat = float(liste[1])        # Récupération de la latitude
        long = float(liste[2][:-1])  # Récupération de la longitude
                                     # [:-1] pour se débarrasser du \n
        liste_temps.append(temps)    # MAJ de la liste liste_temps
        liste_lat.append(lat)        # MAJ de la liste liste_lat
        liste_long.append(long)      # MAJ de la liste liste_long
    return (liste_temps,liste_lat,liste_long) # Tuple formé de trois listes

def longueur_parcours():
    """
        Fonction qui calcule la longueur du parcours passant par les points du
        fichier "CoordGPS.txt".
    """
    liste_temps, liste_lat, liste_long = lecture_fichier()
    return longueur(liste_lat, liste_long)


def liste_vitesses():
    """
        Fonction qui calcule la vitesse entre deux points du fichier
        "CoordGPS.txt".
    """
    liste_temps, liste_lat, liste_long = lecture_fichier()
    liste_v_pro = [] # Liste provisoire contenant les vitesses
    for i in range(1,len(liste_temps)): # On itère sur un indice, ce qui nous
                                        # permet d'accéder aux éléments des deux
                                        # listes
        # On calcule ensuite la vitesse entre deux instants successifs
        liste_v_pro.append(3.6*distance(liste_lat[i-1],liste_long[i-1],\
                                    liste_lat[i],liste_long[i])\
                                    /(liste_temps[i]-liste_temps[i-1]))
    return liste_v_pro


def liste_vitesses_moyennes():
    liste_temps, liste_lat, liste_long = lecture_fichier()
    l_tot = longueur_parcours() # On initialise une variable contenant la
                                # longueur totale du parcours
    d = 0 # On initialise une variable contenant la distance totale parcourue
    i = 0 # On initialise un itérateur de liste
    v_moy = [] # On initialise la liste des vitesses moyennes
    while d < l_tot: # On parcourt les listes tant que l'on a pas atteint la
                     # distance totale
        km = m.floor(d/1000) # On calcule le kilomètre actuel
        t0 = liste_temps[i] # On stocke le temps initial du kilomètre
        d0 = d # On stocke la distance initiale du kilomètre
        while (m.floor(d/1000)==km) and d < l_tot: # Tant que le kilomètre est
                                                   # identique...
            d += distance(liste_lat[i],liste_long[i],\
                      liste_lat[i+1],  liste_long[i+1])
            i += 1
        v_moy.append(3.6*(d-d0)/(liste_temps[i]-t0))
    return v_moy

This snippet took 0.01 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).