[[{"text":"Remplir les champs ci-dessous :","title":"Création d'une carte avec python et leaflet","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"![](\"https://sciencesappliquees.com/images/snt/itineraire.png\")
"}],[{"text":"![\"carte](\"https://sciencesappliquees.com/images/snt/carhaixparis.png\")
![](\"https://sciencesappliquees.com/images/snt/tabdist.png\")
","title":"Déterminer un itinéraire"},{"edit":"
"},{"text":" "},{"edit":"
"}],[{"textnp":"
"},{"text":"
","title":"Exercice : calcul de distance"},{"code":"
"},{"edit":"
Ecrire ici vos réponses.
"}],[{"textnp":"
","title":"Les graphes"},{"text":"
","title":"Création d'une carte"},{"edit":"
234
185
208
"},{"text":"
"},{"edit":"
"}],[{"text":"
","title":"Algorithme d'itinéraire"},{"edit":"
"}],[{"text":"
","title":"La bibliothèque routing"},{"code":"
"},{"edit":"
Répondre ici.
"}],[{"text":"Faites suivant et envoyez votre travail au format pdf à l'adresse mail ci-dessous :
Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.
","title":"Envoyer votre travail"},{"edit":"- https://www.geoportail.gouv.fr/"}]]
Vous avez dans le tableau ci-dessous, un tableau fourni avec une carte routière du xx° siècle.
Il donne
Les longueurs des trajets routiers pour rallier une ville à une autre.
A l'aide du tableau, donnez la distance en voiture entre Carhaix-Plouguer et Paris.
Calculer le temps du voyage, si votre vitesse moyenne est de 90km/h.
Ecrire ici votre réponse.
Quelle propriété possède un tel tableau ?
Expliquer.
Ecrire ici votre réponse.
À partir du tableau, proposer un voyage
en trois étapes de Carhaix à Paris et déterminer la distance à parcourir.
Utiliser l'éditeur Python ci-dessous pour calculer la distance.
dcar_ren = 158
print(dcar_ren,\"km\")
Un tel tableau est difficile à appréhender par les humains. Les applications du type Waze et Google Maps utilisent plutôt des graphes afin de modéliser les données.
En parcourant le graphe ci-dessous, des algorithmes calculent alors le meilleur itinéraire en fonction de divers critères.
Chaque sommet du graphe ci-dessous représente une ville ; Les villes sont | J
reliées deux à deux par des arêtes pondérées par La distance qui Les sépare.
Compléter le graphe avec Les données du tableau.
234
185
208
En utilisant les graphes, a-t-on supprimé la redondance
d'informations par rapport au tableau?
Compléter le graphe en ajoutant les distances avec Saint Brieuc.
D'après Les informations dont vous disposez, quel
serait le chemin le plus court pour aller de Saint Brieuc à Paris?
À votre avis, quelles différences majeures y a-t-il entre le graphe ci-dessous et celui
utilisé par les applications du type Google Maps?
Répondre ici.
Comme vous avez pu le constater quand vous avez travaillé sur Open Street Map, il est possible de définir les voies de communication (principalement les routes). La base de données OSM contient donc les routes (enfin, la plupart des routes…). En utilisant ces données, il est possible de développer des outils capables de calculer des itinéraires routiers (comme le propose tous les logiciels « GPS » : Waze, ViaMichelin, Mappy…) : vous renseignez votre lieu de départ, votre lieu d’arrivée puis le logiciel calcule votre itinéraire.
Ce calcul d’itinéraire repose sur des algorithmes relativement complexes, par exemple l’algorithme de Dijkstra qui permet d’obtenir le plus court chemin entre deux points.
Sans entrer dans les détails, l’algorithme de Dijkstra travaille sur des graphes (chaque ville est un sommet du graphe et chaque route est une arête du graphe), visionnez cette vidéo pour en savoir plus.
Expliquez en quelques lignes le principe de l’algorithme de Dijkstra.
Répondre ici.
La bibliothèque routing machine de géoportail permet de déterminer l'itinéraire entre 2 ponts.
Le code est le suivant :
#gestion de la carte
map( 48 , -0.5 , 7)#Gérer l'itinéraire
routing()
Tracer l'itinéraire entre Carhaix et Paris.
En déduire, le temps du trajet.
Copier la carte ci-dessous.
Copier le parcourt ci-dessous.
Comparer avec le temps que vous aviez calculé.
Sources :
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1491
[[{"text":"Remplir les champs ci-dessous :","title":"Python : Programmation Orientée Objet","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"![\"OOP](\"https://files.realpython.com/media/python3-oop.01ea6aa3e8ef.jpg\")
"},{"edit":"
"}],[{"text":"
","title":"Les classes"},{"edit":"
Ecrire ici le résultat.
"}],[{"text":"
","title":"Exercice"},{"edit":"
Ecrire ici le résultat.
"}],[{"text":"
","title":"Les objets : Intances des classes"},{"edit":"
Répondre ici.
"}],[{"text":"
","title":"Les attributs de classe"},{"edit":"
","title":"Exercice"},{"edit":"
","title":"Les méthodes"},{"edit":"
"}],[{"text":"
"}],[{"text":"
"},{"edit":"
Ecrire ici vos résultats.
","css":"","js":""}],[{"text":"
"}],[{"text":"
","title":"L'attribut spécial __dict__"},{"edit":"
"}],[{"text":"
","title":"L'héritage de classe"},{"edit":"
Ecrire ici les résultats.
"}],[{"text":"
","title":"Polymorphisme / surcharge de méthode"},{"edit":"Ecrire ici les résultats.
"}],[{"text":"
"},{"edit":"
"}],[{"text":"
"},{"edit":"
"}],[{"text":"
Source : https://python.doctor/page-apprendre-programmation-orientee-objet-poo-classes-python-cours-debutants ","title":"Envoyer votre travail"},{"edit":"
"}]]
Source image : https://blog.lakinduakash.com/index.php/learn-object-oriented-programming-oop-in-python-3-within-10-minutes/91/
"}],[{"text":"La programmation orientée objet (POO) permet de créer des entités (objets) que l'on peut manipuler . La programmation orientée objet impose des structures solides et claires. Les objets peuvent interagir entre eux, cela facilite grandement la compréhension du code et sa maintenance. On oppose souvent la programmation objet à la programmation procédurale , la première étant plus \"professionnelle\" que l'autre car plus fiable et plus propre.
Une classe regroupe des fonctions (def) et des attributs qui définissent un objet. On appelle par ailleurs les fonctions d'une classe des \" méthodes \".
Créons une classe Voiture :
# coding: utf-8
class Voiture:
def __init__(self):
self.nom = \"Ferrari\"
Notre classe Voiture est une sorte d'usine à créer des voitures.
La méthode __init__() est appelée lors de la création d'un objet.
self.nom est une manière de stocker une information dans la classe. On parle d'attribut de classe. Dans notre cas, on stock le nom dans l'attribut nom .
Ecrire le programme et le tester avec l'instruction suivante :
print(type(Voiture()))
print(Voiture())
Créer et tester la class Dog :
class Dog:
# Class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
Tester avec les instructions suivantes :
a = Dog()
print(type(a))
Justifier le résultat.
Un objet est une instance d'une classe . On peut créer autant d'objets que l'on désire avec une classe .
Créons maintenant notre voiture:
ma_voiture = Voiture()
Les attributs de classe permettent de stocker des informations au niveau de la classe. Elle sont similaires aux variables.
Dans notre exemple:
ma_voiture = Voiture()
print(ma_voiture)
print(ma_voiture.nom)
Ecrire et exécuter le code ci-dessous.
Vous pouvez à tout moment créer un attribut pour votre objet:
ma_voiture.modele = \"250\"
Et le lire ainsi:
print(\"modèle\",ma_voiture.modele)
Ecrire et exécuter le code ci-dessous.
Ecrire les résultats ici.
"}],[{"text":"Créer 2 objet Dog ou 2 instances de la classe Dog :
# Instantiate the Dog object
philo = Dog(\"Philo\", 5)
mikey = Dog(\"Mikey\", 6)
Ecrire et tester le code ci-dessous avec les instructions suivantes :
# Access the instance attributes
print(\"{} is {} and {} is {}.\".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == \"mammal\":
print(\"{0} is a {1}!\".format(philo.name, philo.species))
Ecrire les résultats ici.
"}],[{"text":"Les méthodes sont des fonctions définies dans une classe.
Modifions la classe Voiture en y ajoutant une nouvelle méthode :
class Voiture:
def __init__(self):
self.nom = \"Ferrari\"
def donne_moi_le_modele(self):
return \"250\"
Utilisons cette méthode:
ma_voiture=Voiture()
print(\"modèle\",ma_voiture.donne_moi_le_modele())
Ecrire les résultats ici.
Quelque soit le langage, pour la programmation orientée objet il est de préférable de passer par des propriétés pour changer les valeurs des attributs. Alors bien que cela ne soit pas obligatoire, il existe une convention de passer par des getter (ou accesseur en francais) et des setter ( mutateurs ) pour changer la valeur d'un attribut. Cela permet de garder une cohérence pour le programmeur, si je change un attribut souvent cela peut également impacter d'autres attributs et les mutateurs permettent de faire cette modification une fois pour toute.
Un exemple d'utilisation de propriétés:
# coding: utf-8
class Voiture(object):
def __init__(self):
self._roues=4
def _get_roues(self):
print \"Récupération du nombre de roues\"
return self._roues
def _set_roues(self, v):
print \"Changement du nombre de roues\"
self._roues = v
roues=property(_get_roues, _set_roues)
Quand on changera la valeur du nombre de roues, un message apparaîtra. En soi cela n'apporte rien mais au lieu de faire un simple print , vous pouvez par exemple envoyer un mail, etc.
Utiliser la classe avec:
ma_voiture=Voiture()
Changement du nombre de roues
ma_voiture.roues=5
Récupération du nombre de roues
print(\"nb roues\",ma_voiture.roues)
Ecrire et exécuter le code ci-dessous.
Il existe une autre syntaxe en passant par des décorateurs:
class Voiture(object):
def __init__(self):
self._roues=4
@property
def roues(self):
print \"Récupération du nombre de roues\"
return self._roues
@roues.setter
def roues(self, v):
print \"Changement du nombre de roues\"
self._roues = v
Le résultat sera le même, mais la lecture du code se trouve amélioré.
","title":"Les propriétés"},{"edit":" Ecrire ici vos résultats.
Il existe une autre syntaxe en passant par des décorateurs:
# coding: utf-8
class Voiture(object):
def __init__(self):
self._roues=4
@property
def roues(self):
print(\"Récupération du nombre de roues\")
return self._roues
@roues.setter
def roues(self, v):
print(\"Changement du nombre de roues\")
self._roues = v
Tester la classe ci-dessous avec les instructions suivantes et conclure.
ma_voiture=Voiture()
ma_voiture.roues=5
print(\"nb roues\",ma_voiture.roues)
Ecrire ici vos résultats.
Parfois il est intéressant de decortiquer un objet pour résoudre à un bug ou pour comprendre un script.
La fonction dir vous donne un aperçu des méthodes de l'objet:
print(dir(ma_voiture))
Ecrire et tester l'instruction dir.
","title":"La fonction dir"},{"edit":" Ecrire ici le résultat.
Cet attribut spécial vous donne les valeurs des attributs de l'instance:
ma_voiture.__dict__
Tester avec le code suivant ;
# coding: utf-8
class Voiture:
def __init__(self):
self.nom = \"Ferrari\"
def donne_moi_le_modele(self):
return \"250\"
ma_voiture=Voiture()
print(ma_voiture.__dir__)
Ecrire ici le résultat.
L'héritage est un concept très utile. Cela permet de créer de nouvelles classes mais avec une base existante.
Gardons l'exemple de la voiture et créons une classe VoitureSport :
class Voiture:
roues = 4
moteur = 1
def __init__(self):
self.nom = \"A déterminer\"
class VoitureSport(Voiture):
def __init__(self):
self.nom = \"Ferrari\"
On a indiqué que VoitureSport a hérité de classe Voiture , elle recupère donc toutes ses méthodes et ses attributs.
On peut toujours instancier la classe Voiture si on le désire:
ma_voiture=Voiture()
print(\"nom\",ma_voiture.nom)
print(\"nb roues\",ma_voiture.roues)
Instancions maintenant la classe VoitureSport :
ma_voiture_sport=VoitureSport()
print(\"sport\",ma_voiture_sport.nom)
print(\"nb roues\",ma_voiture_sport.roues)
Ecrire et tester les codes ci-dessous et conclure.
On remarque tout d'abord que l'attribut roues a bien été hérité. Ensuite on remarque que la méthode __init__ a écrasé la méthode de la classe Voiture . On parle alors de surcharge de méthode.
Comme nous l'avons vu précédemment une classe hérite d'une autre classe, elle hérite les méthodes de son parent .
Exemple:
# coding: utf-8
class Voiture:
roues = 4
moteur = 1
def __init__(self):
self.nom = \"A déterminer\"
def allumer(self):
print(\"La voiture démarre\")
class VoitureSport(Voiture):
def __init__(self):
self.nom = \"Ferrari\"
ma_voiture_sport = VoitureSport()
ma_voiture_sport.allumer()
Ecrire et tester le code ci-dessous.
Il est cependant possible d' écraser la méthode de la classe parente en la redéfinissant. On parle alors de surcharger une méthode .
# coding: utf-8
class Voiture:
roues = 4
moteur = 1
def __init__(self):
self.nom = \"A déterminer\"
def allumer(self):
print(\"La voiture démarre\")
class VoitureSport(Voiture):
def __init__(self):
self.nom = \"Ferrari\"
def allumer(self):
print(\"La voiture de sport démarre\")
ma_voiture_sport = VoitureSport()
ma_voiture_sport.allumer()
Tester le code et conclure.
Enfin dernier point intéressant: il est possible d'appeler la méthode du parent puis de faire la spécificité de la méthode. On peut d'ailleurs appeler n'importe quelle autre méthode.
# coding: utf-8
class Voiture:
roues = 4
moteur = 1
def __init__(self):
self.nom = \"A déterminer\"
def allumer(self):
print(\"La voiture démarre\")
class VoitureSport(Voiture):
def __init__(self):
self.nom = \"Ferrari\"
def allumer(self):
Voiture.allumer(self)
print(\"La voiture de sport démarre\")
ma_voiture_sport = VoitureSport()
ma_voiture_sport.allumer()
Tester le code et conclure.
Les classes Voiture et VoitureSport possédent donc chacune une méthode de même nom mais ces méthodes n'effectuent pas les mêmes tâches. On parle dans ce cas de polymorphisme
"},{"edit":"Ecrire ici les résultats.
"}],[{"text":"Tester le code et conclure :# Parent class
class Dog:
# Class attribute
species = 'mammal'
# Initializer / Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# instance method
def description(self):
return \"{} is {} years old\".format(self.name, self.age)
# instance method
def speak(self, sound):
return \"{} says {}\".format(self.name, sound)
# Child class (inherits from Dog class)
class RussellTerrier(Dog):
def run(self, speed):
return \"{} runs {}\".format(self.name, speed)
# Child class (inherits from Dog class)
class Bulldog(Dog):
def run(self, speed):
return \"{} runs {}\".format(self.name, speed)
# Child classes inherit attributes and
# behaviors from the parent class
jim = Bulldog(\"Jim\", 12)
print(jim.description())
# Child classes have specific attributes
# and behaviors as well
print(jim.run(\"slowly\"))
Ecrire ici les résultats.
Tester le code et conclure :
# Parent class
class Dog:
# Class attribute
species = 'mammal'
# Initializer / Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# instance method
def description(self):
return \"{} is {} years old\".format(self.name, self.age)
# instance method
def speak(self, sound):
return \"{} says {}\".format(self.name, sound)
# Child class (inherits from Dog() class)
class RussellTerrier(Dog):
def run(self, speed):
return \"{} runs {}\".format(self.name, speed)
# Child class (inherits from Dog() class)
class Bulldog(Dog):
def run(self, speed):
return \"{} runs {}\".format(self.name, speed)
# Child classes inherit attributes and
# behaviors from the parent class
jim = Bulldog(\"Jim\", 12)
print(jim.description())
# Child classes have specific attributes
# and behaviors as well
print(jim.run(\"slowly\"))
# Is jim an instance of Dog()?
print(isinstance(jim, Dog))
# Is julie an instance of Dog()?
julie = Dog(\"Julie\", 100)
print(isinstance(julie, Dog))
# Is johnny walker an instance of Bulldog()
johnnywalker = RussellTerrier(\"Johnny Walker\", 4)
print(isinstance(johnnywalker, Bulldog))
# Is julie and instance of jim?
print(isinstance(julie, jim))
Ecrire ici les résultats.
Prenez l'habitude de nommer votre classe uniquement avec des caractères alphanumériques et commençant par une majuscule. Et à l'inverse l'instance peut être nommée sans majuscule.
voiture_sport = VoitureSport()
","title":"Conventions"},{"edit":" "}],[{"text":"Faites suivant et envoyez votre travail au format pdf à l'adresse mail ci-dessous :
Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1733
[[{"text":"Remplir les champs ci-dessous :","title":"Création d'une carte avec python et leaflet","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"
"}],[{"text":"Après avoir regardé les deux vidéos ci-dessous, rédigez un texte de quelques lignes sur le principe du fonctionnement du GPS et de Galileo.
"},{"edit":"
"}],[{"text":"
"},{"edit":"
Ecrire ici la réponse.
"}],[{"text":"
","title":"Création d'une carte"},{"code":"
"},{"edit":"
Répondre ici.
"}],[{"text":"
","title":"Ma ville"},{"code":"
"},{"edit":"
"}],[{"text":"
","title":"Zoom"},{"code":"
"},{"edit":"
Répondre ici.
"}],[{"text":"
","title":"Les marqueurs"},{"code":"
"},{"edit":"
"}],[{"text":"
import map
#gestion de la carte
map( 48.278642, -3.551123,16 )
"},{"edit":"
"}],[{"text":"
","title":"Créer votre carte"},{"code":"
"},{"edit":"
"}],[{"text":"Faites suivant et envoyez votre travail au format pdf à l'adresse mail ci-dessous :
Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez activer le JavaScript pour la visualiser.
","title":"Envoyer votre travail"},{"edit":" "}]]
"},{"edit":"
Ecrire ici votre texte.
Le temps mis par le signal envoyé par un satellite Galiléo et reçu par un récepteur est de 76,7ms.
Calculer la distance entre le récepteur et le satellite.
Rappel ; La vitesse de la lumière est de 3.10^8 m/s ou 300000000m/s
","title":"Exercice : calcul de distance"},{"code":"v = 300000000
print(v)
Vous allez utiliser la librairie leaflet et saisir le programme ci-dessous.
Copier et exécuter le code
import map
#gestion de la carte
map( 48 , -2.5 )
\t\t
Notez bien que nous avons une véritable carte et pas une simple image (il est possible de zoomer ou de se déplacer).
Faites une copie d’écran de la carte et insérez la dans \"Répondre ici\".
Le programme est simple à comprendre :
La première ligne : « import map » permet d’importer la bibliothèque leaflet afin de pouvoir l’utiliser
La deuxième ligne est le coeur de notre programme, nous créons un objet carte. « map . map( 48 , -2.5 ) génère un objet carte centrée sur le point de latitude « 48 » et de longitude « 2.5 ».
Plus généralement nous avons « map(latitude, longitude , zoom) ». Il suffit donc de renseigner la bonne longitude et la bonne latitude pour que la carte soit centrée sur le point désiré.
import map
#gestion de la carte
map( 48 , -2.5 , 9 )
Modifiez le programme précédent pour qu’il génère une carte centrée sur votre ville (la longitude et la latitude d’une ville sont facilement trouvables sur le web).
Faites une copie d’écran de la carte et insérez la dans \"Répondre ici\".
Répondre ici.
Il est possible d’obtenir un niveau de zoom différent en ajoutant un 3ème paramètre zoom.
map( 48 , -2.5 , 10)
Saisissez et testez le programme ci-dessous
import map
#gestion de la carte
map( 48 , -2.5 ,10)
\t\t
Plus sa valeur sera grande et plus le zoom sera important.
Modifier le programme pour zoomer sur votre ville.
Faites une copie d’écran de la carte et insérez la dans \"Répondre ici\".
Afin de vraiment personnaliser la carte, il est possible d’ajouter des marqueurs sur la carte. Un marqueur sera simplement défini par ses coordonnées (latitude et longitude).
Saisissez et testez le programme ci-dessous
import map
#gestion de la carte
map( 48 , -2.5 )
#ajouter un marqueur
marker( 48 , -2.5 )
\t\t
Nous avons uniquement ajouté la ligne « marker… », il faut juste renseigner les coordonnées souhaitées (ici 48 pour la latitude et -2.5 pour la longitude)
Il est possible d’ajouter plusieurs marqueurs sur une même carte, il suffira d’ajouter autant de ligne « marker(latitude, longitude) » que de marqueurs désirés.
Modifier le programme pour que le marker soit centré sur votre ville.
Faites une copie d’écran de la carte et l'insérer dans \"Répondre ici\".
.
Répondre ici.
Il est possible d’associer une information à un marqueur en ajoutant un 3ème paramètre.
marker( 48 , -2.5, \"mon information\" )
Saisissez et testez le programme ci-dessous
#gestion de la carte
map( 48.278642, -3.551123,16 )
#localiser un point
map.click()
","title":"Les marqueurs"},{"code":"#ajouter un marqueur
marker( 48.278642, -3.551123 ,\"Lycée Sérusier\")
\t\t
Il suffit de cliquer sur le marqueur pour que l’information définie par le 3ème paramètre « popup » apparaisse à l’écran (ici en cliquant sur le marqueur nous verrons donc apparaitre « Lycée Sérusier »).
L'instruction map.click(), détermine votre position sur la carte.
Modifier le programme pour que le marqueur soit centré et indique le nom de votre ville.
Faites une copie d’écran de la carte et l'insérer dans \"Répondre ici\".
import map
#gestion de la carte
map( 48.278642, -3.551123,16 )
#gestion de la carte
map( 48.278642, -3.551123,16 )
#localiser un clique
map.click()
#ajouter un marqueur
marker( 48.278642, -3.551123 ,\"Lycée Sérusier\")
.
Répondre ici.
Maintenant que vous savez utiliser leaflet. Vous allez créer une carte de votre ville qui indiquera (marqueur) les positions suivantes :
- La mairie:
- L'église;
- L'école;
- La boulangerie;
- Votre domicile.
\t
Réaliser le programme.
Remarque ; L'instruction map.click() permet d'afficher la latitude et la longitude du point cliqué sur la carte..
Faites une copie d’écran de la carte et l'insérer dans \"Répondre ici\".
.
Répondre ici.
Sources :
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1178
Installer les éléments suivants :
sudo chown -R $(whoami) /usr/local/lib/pkgconfig
brew install tesseract
brew install tesseract-lang
sudo pip3 install pytesseract
sudo pip3 install numpy
sudo pip3 install opencv-python==4.1.2.30
- Détails
- Écrit par : Richard GAUTHIER
- Clics : 1134