[[{"text":"Remplir les champs ci-dessous :","title":"DIFFÉRENTS RÉSEAUX SOCIAUX","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"![\"liste](\"https://www.leptidigital.fr/wp-content/uploads/2019/02/liste-reseaux-sociaux.jpg\")
Source : https://www.leptidigital.fr/reseaux-sociaux/liste-reseaux-sociaux-14846/
"}],[{"text":"
"}],[{"text":"
"},{"edit":"
Ecrire ici vos réponses.
"}],[{"text":"
"}],[{"text":"
"},{"edit":"
"}],[{"text":"![\"Identnum1.png](\"https://sciencesappliquees.com/images/snt/Identnum1.png\")
","title":"Identité numérique par le dessin de presse"},{"edit":"
Répondre ici.
"},{"text":"
Répondre ici.
"}],[{"text":"![\"identnum2.png](\"https://sciencesappliquees.com/images/snt/identnum2.png\")
","title":"Identité numérique par le dessin de presse"},{"edit":"
Répondre ici.
"},{"text":"
Répondre ici.
"}],[{"text":"![\"identnum3.png](\"https://sciencesappliquees.com/images/snt/identnum3.png\")
","title":"Identité numérique par le dessin de presse"},{"edit":"
Répondre ici.
"},{"text":"
Répondre ici.
"}],[{"text":"![\"identnum3.png](\"https://sciencesappliquees.com/images/snt/identnum4.png\")
","title":"Identité numérique par le dessin de presse"},{"edit":"
Répondre ici.
"},{"text":"
Répondre ici.
"}],[{"text":"![\"identnum3.png](\"https://sciencesappliquees.com/images/snt/identnum5.png\")
","title":"Identité numérique par le dessin de presse"},{"edit":"
Répondre ici.
"},{"text":"
Répondre ici.
"}],[{"text":"![\"CNIL_conseils-web.png](\"https://sciencesappliquees.com/images/ETT/CNIL_conseils-web.png\")
"}],[{"text":"
","title":"Etes-vous sur le web?"},{"edit":"
"}],[{"text":"
![](\"https://icn-isn-boissy.yj.fr/wp/wp-content/uploads/2020/03/Image1-droit-%C3%A0-loubli.png\")
","title":"Effacer mes données sur le web"},{"edit":"
Ecrire votre courier ici.
"}],[{"text":"
","title":"Envoyer votre travail"},{"edit":" "}]]
Source : https://www.leptidigital.fr/reseaux-sociaux/liste-reseaux-sociaux-14846/
Regardez les vidéos suivantes :
Résumez en quelques lignes les deux vidéos.
"},{"edit":" Ecrire ici votre résumé.
En fonction de vos goûts, vous étudierez deux des réseaux sociaux ci-dessous :
- Facebook
- Twitter
- LinkedIn
- Instagram
- Snapchat
- WhatsApp
- Pinterest
Après avoir rappelé le principe de fonctionnement du réseau social, vous essayerez de trouver sur le net son nombre d’abonnées actuel (et si possible sa « dynamique de croissance » : est-ce que son nombre d’abonnées est plutôt en hausse, plutôt en baisse ou stable).
Répondez à cette série de questions sur les 2 réseaux que vous avez sélectionnés :
- Les utilisateurs de ce réseau social ont-ils la possibilité de « régler » des « paramètres de confidentialité » afin de pouvoir préserver le respect de leur vie privée ?
Si, oui, ces « paramètres de confidentialité » sont-ils facilement accessibles ?
- Est-il facile de se désinscrire de ce réseau social ?
- Le réseau social propose-t-il une procédure simple afin qu’un utilisateur puisse obtenir une copie des données qui auront été « récoltées » sur lui ? Si oui, la procédure est-elle simple à mettre en oeuvre ?
-Le réseau social efface-t-il toutes traces des données personnelles d’un utilisateur qui s’est désinscrit ?
"},{"edit":"Répondre ici.
Quels sont les sources de revenus des 2 réseaux sociaux que vous avez sélectionné?
Répondre ici.
Décrivez la situation représentée : qui fait\nquoi, où sont les personnages?
Quel est le message de ce dessin ?
"},{"edit":"Décrivez la situation représentée : qui fait\nquoi, où sont les personnages?
Quel est le message de ce dessin ?
"},{"edit":"Décrivez la situation représentée : qui fait\nquoi, où sont les personnages?
Quel est le message de ce dessin ?
"},{"edit":"Décrivez la situation représentée : qui fait\nquoi, où sont les personnages?
Quel est le message de ce dessin ?
"},{"edit":"Décrivez la situation représentée : qui fait\nquoi, où sont les personnages?
Quel est le message de ce dessin ?
"},{"edit":"Notez ( les mots clés) les dix conseils de la CNIL à respecter sur le web..
","title":"Les conseils de la CNIL"},{"edit":" Répondre ici.
Recherchez votre nom Prénom sur 4 différents moteurs de recherche
Notez sur votre compte rendu le nombre de fois que vous apparaissez sur les différents moteurs de recherche, relevez le nombre de réseaux sociaux auxquels vous appartenez même inactif.
Connaissez vous l’existence de tous les articles à votre nom ?
Répondez ici.
Préparez (sans l’envoyer) une lettre comme celle ci-dessous pour demander à un site quelconque de vous supprimer les données.
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 : 1442
[[{"text":"Remplir les champs ci-dessous :","title":"Python : Les expressions régulières","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"![](\"https://miro.medium.com/max/4968/1*m3wegA5h10b8aM5U64xtSA.png\")
","title":"Poser le problème."},{"edit":"
"}],[{"text":"
"}],[{"text":"
","title":"Exercice"},{"edit":"
Ecrire ici le résultat.
"}],[{"text":"
","title":"Remplacer."},{"edit":"
"}],[{"text":"
","title":"Découper."},{"edit":"
"}],[{"text":"
","title":"Les «expressions régulières »"},{"edit":"
"}],[{"text":"
","title":"Matching et Searching."},{"edit":"","css":"","js":""}],[{"text":"
"}],[{"text":"
","title":"Compiler le patron."},{"edit":"
"}],[{"text":"
","title":"Comparer et chercher"},{"edit":"
Ecrire ici vos réponses.
"}],[{"text":"
","title":"Remarque sur les expression régulière"},{"edit":""}],[{"text":"
","title":"les jokers et marqueurs fondamentaux"},{"edit":"
"}],[{"text":"
","title":"Répétitions d'un caractère"},{"edit":""}],[{"text":"
","title":"consommation"},{"edit":"
"}],[{"text":"
","title":"Echappement"},{"edit":"
"}],[{"text":"
"}],[{"text":"
","title":" Remplacer : la méthode sub()"},{"edit":"
Ecrire ici les résultats.
"}],[{"text":"
","title":"La méthode split()"},{"edit":"
Ecrire ici les résultats.
"}],[{"text":"
Sources : http://ateliers.mse.free.fr/regex/regex-python.pdf","title":"Envoyer votre travail"},{"edit":"
"}]]
Source de l'image :
"}],[{"text":"On dispose d'un texte, c'est à dire pour Python d'une chaîne de caractères (string).
Par ailleurs, on propose un motif, qui est lui aussi une chaîne de caractères.
Le problème consiste à détecter la présence du motif dans le texte, et éventuellement de remplacer ce motif par un autre..
Nous avons des fonctions définies par python qui peuvent résoudre le problème:
str.find(sub[, start[, end]])
retourne le premier indice de la chaîne où la sous-chaîne sub est trouvée ; si start et end sont précisés, le domaine de recherche est la sous-chaîne formée des caractères dont l'indice est entre les valeurs de start et de end (la tranche commence avec start et se termine avant end). La méthode retourne -1 en cas d'échec de la recherche.
str.index(sub[, start[, end]])
comme find(), mais lève une exception ValueError si la sous-chaîne n'est pas trouvée.
Cela permet de programmer les ruptures de séquences avec des exceptions. str.rfind(sub[, start[, end]])
comme find(), mais commence par la fin de la chaîne.
str.rindex(sub[, start[, end]])
comme rfind() mais lève une exception ValueError si la sous-chaîne n'est pas trouvée.
str.count(sub[, start[, end]])
retourne le nombre d'occurrences de la sous-chaîne sub dans la tranche [start,end]
","title":"Trouver"},{"edit":"On a la chaine de caractère suivante :
texte = \"\"\"
Un IDE ou environnement de développement est un logiciel constitué d'outils qui facilitent l'écriture et les tests dans un ou plusieurs langages de programmation.\\n
Cet IDE comporte en général un éditeur avec coloration syntaxique,\\nun système de gestion de fichiers (sauvegarde/chargement),\\nun compilateur, un exécuteur de programme, un système d'aide en ligne,\\ndes indicateurs de syntaxe etc.
Le plus connu est peut être Éclipse.
\"\"\"
La première occurence du motif. La numérotation commence 0
motif = \"IDE\"
resultat = texte.find(motif)
print (\"première occurence du motif :\", resultat)
Le nombre d'occurrences du motif
resultat= texte.count (motif)
print (\"nombre d'occurrences du motif :\",resultat)
Rechercher un motif avec problème de casse (caractère en minuscule ou majuscule)
motif = \"éclipse\"
resultat = (texte.upper()).find(motif.upper())
print (motif, \"est présent comme\",texte[resultat:resultat+len(motif)])
Ecrire et tester le code ci-dessus.
Il existe une fonction pour remplacer un motif dans un texte:
str.replace(old, new[, count])
retourne une copie de la chaîne où toutes les occurrences de la sous-chaîne old sont remplacées par la chaîne new. Si la valeur count est précisée, seules les count premières occurrences sont remplacées.
Remplacer le motif \\n (Retour à la ligne) par un espace (\" \").
print (texte)
motif = \"\\n\"
resultat = texte.replace(motif, \" \")
print (resultat)
Ecrire et tester le code.
Mettre le résultat ci-dessous.
","title":"Exercice"},{"edit":" Ecrire les résultats ici.
"}],[{"text":"Avec python, nous pouvons découper une chaîne de texte. Pour cela, nous avons les fonctions suivantes:
str.split([sep[, maxsplit]])
retourne une liste de mots de la chaîne, en utilisant sep comme délimiteur. Si maxsplit est
donné, il y a au plus maxsplit coupures (et la liste a au plus maxsplit+1 éléments).
En l'absence de séparateur spécifié, ou avec le séparateur None, l'espace est considéré
comme séparateur.
str.splitlines([keepends])
retourne une liste des lignes de la chaîne. En principe, le séparateur de ligne n'est pas gardé, sauf si keepend est posé à True.
Ecrire les résultats ici.
"}],[{"text":"Découper une chaîne de caractère avec la fonction split:
texte = \"123,,456,\"
print(\"texte :\",texte)
# split
liste = texte.split (\",\")
print(\"liste :\", liste)
Découper une chaîne de caractère en liste à l'aide \\n (retour à la ligne).
texte = \"\\nABC\\nDEF\\nGHI\"
print (\"texte :\",texte)
liste = texte.splitlines()
print (\"liste :\", liste)
Découper une chaîne de caractère en liste à l'aide \\n et keepend
texte = \"\\nABC\\nDEF\\nGHI\"
print(\"texte :\",texte)
liste = texte.splitlines(True)
print(\"\\nliste :\", liste)
Tester les instructions et mettre le résultat ci-dessous.
","title":"Exercice"},{"edit":" Ecrire les résultats ici.
Les expressions régulières ou Regex (contraction de regular expression) est une manière commune de nommer les expressions régulières. Ces puissants outils permettent de représenter des spécimens de chaînes de caractères.
Les Regex sont employées pour examiner, changer et manier du texte comme nous l'avons réalisé précédemment.
On peut les voir dans des langages tels que Javascript, Python ou C
Pour utilser les expressions régulières en Python, il faut commencer par importer le module re :
import re # module des expressions régulières
Si nous reprenons le programme suivant qui permet de remplacer les \\n par un espace (\" \"):
texte = \"\"\"
Un IDE ou environnement de développement est un logiciel constitué d'outils qui facilitent l'écriture et les tests dans un ou plusieurs langages de programmation.\\n
Cet IDE comporte en général un éditeur avec coloration syntaxique,\\nun système de gestion de fichiers (sauvegarde/chargement),\\nun compilateur, un exécuteur de programme, un système d'aide en ligne,\\ndes indicateurs de syntaxe etc.
Le plus connu est peut être Éclipse.
\"\"\"
print(texte)
motif = \"\\n\"
resultat = texte.replace(motif, \" \")
print(resultat)
En utilisant, les expréssions régulières devient :
texte = \"\"\"
Un IDE ou environnement de développement est un logiciel constitué d'outils qui facilitent l'écriture et les tests dans un ou plusieurs langages de programmation.\\n
Cet IDE comporte en général un éditeur avec coloration syntaxique,\\nun système de gestion de fichiers (sauvegarde/chargement),\\nun compilateur, un exécuteur de programme, un système d'aide en ligne,\\ndes indicateurs de syntaxe etc.
Le plus connu est peut être Éclipse.
\"\"\"
motif = \"\\n\"
resultat = re.sub(\"\\n\", \" \", texte)
print(resultat)
Tester les 2 codes et conclure.
Ecrire ici vos résultats.
Pour la clarté du cours, nous traduirons lez verbes
to match par correspondre à,
et to search par rechercher.
Il ne faut pas chercher de signification \"intuitive\" à ces concepts qui ont un sens précis en Python.
On dispose d'un texte, c'est à dire pour Python une chaîne de caractères ; par ailleurs, on propose un patron (ou motif), qui est lui aussi une chaîne de caractères.
Le problème consiste à détecter une sous-chaîne respectant le patron dans le texte et éventuellement à remplacer par une chaîne prédéfinie la (ou les) sous-chaînes(s) trouvées.
D'autres opérations sont possibles, qui seront vues plus tard.
","title":"Poser le problème"},{"edit":" Ecrire ici le résultat.
La syntaxe pour compiler un patron est la suivante :
cpatron = re.compile(patron, directives)
Les directives se présentent sous forme d'un entier : chaque directive est une puissance de deux, et le paramètre directives est la somme de directives particulières.
| Constante | Abrégé | Valeur | Signification |
| IGNORECASE | I | 2 | ignorer la casse ; fonctionne avec les lettres accentuées |
| LOCALE | L | 4 | définir comme \"lettre\" ce que la langue locale définit comme tel dans la variable système.; |
| MULTILINE | M | 8 | considèrer le texte comme décomposé en lignes (le caractère \\n est le début de chaque ligne) |
| DOTALL | S | 16 | considèrer le saut de ligne comme un caractère ordinaire. |
| UNICODE | U | 32 | obsolète dans Python 3 |
| VERBOSE | X | 64 | permettre d'écrire des commentaires dans les patrons. |
| ASCII | A | 256 | permettre de travailler en ASCII |
On peut écrire indifféremment
re.IGNORECASE+re.MULTILINE ou re.I+re.M
Pour l'instant, nous travaillerons avec les directives IGNORECASE, MULTILINE et DOTALL.
On verra plus tard la directive VERBOSE.
La syntaxe des fonctions comparer et chercher est la suivante :
cpatron.search (texte)
cpatron.match (texte)
La recherche (search()) consiste à parcourir le texte depuis le début ; si le patron n'est pas identifiable dans le texte, la fonction retourne None. Sinon, elle retourne une instance de l'objet MatchObject, appartenant lui aussi au module _sre.
La comparaison (match()) consiste à identifier le début du texte au patron. Elle retourne None si aucune comparaison n'est possible. Sinon elle retourne une instance MatchObject.
L'objet : MatchObject
Cet objet peut être interrogé par ses méthodes. Pour l'instant, les méthodes start() (premier caractère reconnu) et stop() (position après le dernier caractère reconnu)
Nous importons la bibliothèque re et nous définissons la variable texte.
import re
texte = \"Un IDE ou \\\"environnement de développement\\\" est un logiciel \\
constitué d'outils qui facilitent l'écriture et les tests dans un \\
langage défini, voire plusieurs.\\
\\nCet IDE comporte en général un éditeur avec coloration syntaxique,\\
un système de gestion de fichiers (sauvegarde/chargement),\\
un compilateur, un exécuteur de programme, un système d'aide en ligne,\\
des indicateurs de syntaxe etc. \\
\\nLe plus connu est peut être Éclipse.\"
Pour rechercher un patron dans le texte, nous utilisons les instructions suivantes :
# recherche du patron dans le texte
patron = \"Cet IDE\"
cpatron = re.compile(patron)
resultat = cpatron.search(texte)
if resultat :
print (resultat.start(), resultat.end())
else:
print (resultat)
Pour la comparaison du patron au texte, nous utilisons les instructions suivantes
# comparaison du patron au texte
resultat = cpatron.match(texte)
if resultat :
print (resultat.start(), resultat.end())
else :
print (resultat)
Pour la comparaison du patron au texte, nous utiliserons les instructions suivantes:
# comparaison du patron au texte ; résultat affiché : None
resultat = cpatron.match(texte)
if resultat :
print (resultat.start(), resultat.end())
else :
print (resultat)
# comparaison du patron au texte ; résultat affiché : 0 6
patron = \"Un IDE\"
cpatron = re.compile (patron)
resultat = cpatron.match(texte)
if resultat :
print (resultat.start(), resultat.end())
else :
print (resultat)
Pour recherche en ignorant la casse, nous utiliserons les instructions suivantes:
# recherche en ignorant la casse
patron = \"éclipse\"
cpatron = re.compile (patron, re.IGNORECASE)
resultat = cpatron.search(texte)
if resultat :
print (resultat.start(), resultat.end())
else:
print (resultat)
Il existe plusieurs présentations syntaxiques pour les méthodes comme search(). Dans le script ci-dessus, search() est une méthode de l'objet SRE_Pattern. Mais Python l'a également redéfini comme une fonction du module re :
exemple :
re.search(patron, texte, re.IGNORECASE))...
Pour la clarté de l'exposé, on s'en tient à une seule syntaxe, celle du script ci-dessus, qui a l'avantage
de ressembler à ce qui se fait en java.
Copier et exécuter le code.
Justifier les résultats.
Ecrire ici vos réponses.
La partie précède a pour objectif de spécifier une syntaxe : celle requise par le module re pour faire des opérations assez semblables à celles réalisées avec plus de simplicité.
Quel est l'apport du module re pour les opérations de recherche, de comparaison, de substitution, de découpage de chaînes ? Lorsque l'on fait une recherche ou une substitution dans un traitement de texte ou un éditeur, la chaîne recherchée doit être explicite.
On peut imposer de ne pas différencier majuscules et minuscules, ou de ne rechercher que des mots entiers ; ces aménagements sont insuffisants.
Remarque : Les éditeurs et traitements de texte actuels peuvent travailler différemment !
On peut souhaiter disposer, pour écrire les patrons, de jokers (comme le * ou le ?) ou de conditions (exemple : trouver les virgules qui sont suivies d'un caractère alphabétique ; trouver les espaces multiples ; se limiter aux caractères alphanumériques).
Les expressions régulières sont des chaînes comportant des jokers et des éléments de description de chaînes de caractères.
La liste des jokers avec les regexp sont les suivants :
| Signe | Signification générale |
| . | le point remplace tout caractère sauf le saut de ligne (\\n). sous DOTALL, le point représente tout caractère, y compris le saut de ligne. |
| ^ | Le chevron (circonflexe) représente le début de la chaîne analysée. sous MULTILINE, représente en plus la position après le saut de ligne |
| $ | Le dollar représente la fin de la chaîne analysée. sous MULTILINE, représente en plus la position avant le saut de ligne. |
Des exemples d'utilisation des jokers :
Si on met \"azer.tyiop\" : cette expression régulière correspond à : azer suivi de n'importe quel
caractère, suivi de tyiop sur une ligne.
En mode DOTALL, le caractère peut être le saut de ligne.
Si nous sommes en recherche, on aura comme résultat: azeratyiop, azerAtyiop, azer(tyiop, azer.tyiop satisfont au modèle proposé.
Si on met \"^aze\" : le patron \"aze\" doit être recherché en début de texte uniquement en début de texte.
En mode MULTILINE, il est aussi recherché en début de chaque ligne.
Si on met \"tyiop$\" : le patron \"tyiop\" est recherché en fin de texte.
En mode MULTILINE, il est aussi recherché en fin de chaque ligne. \"^$\" : recherche d'un texte vide ou en mode MULTILINE d'une ligne vide.
Les symboles de répétitions d'un caractère sont les suivants :
| itérateur | interprétation |
| * | zéro, une ou plusieurs fois le caractère qui précède |
| + | une ou plusieurs fois le caractère qui précède |
| ? | zéro ou une fois le caractère qui précède |
| {m} | exactement m fois le caractère qui précède |
| {m,} | au moins m fois le caractère qui précède |
| {m,n} | au moins m fois et au plus n fois le caractère qui précède |
Des exemples d'utilisations des symboles de répétition:
exp. reg. -> chaînes reconnues
ab*c -> ac, abc, abbc, abbbc, ...
ab+c -> abc, abbc, abbbc, ...
ab?c -> ac, abc
ab{2,}c -> abbc, abbbc, abbbbc, ....
ab{2,4}c -> abbc, abbbc, abbbbc
Lorsqu'une recherche est couronnée de succès, la partie de la chaîne comprise entre le début de celle-ci et la fin de la sous-chaîne trouvée est consommée. Ce qui signifie par exemple que la fonction findall() commence la recherche à partir du caractère suivant le dernier caractère consommé. La recherche est séquentielle et elle ne fait aucun retour en arrière.
Ecrire ici les résultats.
"}],[{"text":"Les itérateurs *, +, ? sont gourmands. C'est-à-dire que dans une recherche, ils ont un comportement qui conduit à reconnaître la plus grande chaîne possible. Ils consomment la chaîne au maximum, même si une correspondance a déjà été trouvée sur le patron proposé.
Par exemple, supposons que l'on ait :
texte = \"<h1>Expressions Régulières</h1>\"
patron = \"<.*>\"
Le sous-motif .* conduit à avoir le plus grand texte possible : l'expression régulière s'identifie à tout le texte.
Il faut lire patron comme :
le caractère < pour commencer ;
un maximum de caractères ;
le caractère > pour finir.
On aurait pu souhaiter au contraire une identification à <h1>, c'est-à-dire :
le caractère < pour commencer ;
un minimum de caractères ;
le caractère >.
Une nouvelle classe d'itérateurs réalisent ces opérations :
itérateur -> interprétation
*? -> zéro, une ou plusieurs fois le caractère qui précède ; non gourmand. Dans une expression, *? s'identifie à la plus petite chaîne possible.
+? -> une ou plusieurs fois le caractère qui précède ; non gourmand.
?? -> zéro ou une fois le caractère qui précède ; non gourmand.
{m,n}? -> le caractère qui précède m fois.
Application :
import re
texte = \"<<aaAAabbbccaaannn\"
print(\"le texte :\",texte)
patron = \"a{2,3}b?\"
cpatron = re.compile(patron, re.I)
res = cpatron.findall(texte)
print (\"patron :\",patron,\"résultat : \",res)
patron = \"a{2,3}?b?\"
cpatron = re.compile(patron, re.I)
res = cpatron.findall(texte)
print (\"patron :\",patron,\"résultat : \",res)
patron = \"a{2,3}b??\"
cpatron = re.compile(patron, re.I)
res = cpatron.findall(texte)
print (\"patron :\",patron,\"résultat : \",res)
Copier et tester le code.
Justifier le résultat.
","title":"Gourmandise."},{"edit":"Ecrire ici les résultats.
Les jokers et les opérateurs sont des caractères courants. Comment, dans une expression régulière peut-on distinguer ce caractère en tant que caractère et le même en tant qu'opérateur ou composant d'un opérateur?
On utilise le même système que Python dans ce cas : pour considérer un caractère comme se représentant lui-même, il faut l'échapper par un antislash. On aura donc pour le point \\., pour l'astérisque \\*, pour le signe plus \\+ et ainsi de suite.
La méthode search() permet de trouver la première sous-chaîne qui correspond à l'expression régulière donnée comme patron. On peut itérer la recherche grâce à la fonction findall(), qui retourne tous les éléments qui correspondent dans une liste de chaînes.
Application :
On dispose d'une liste de noms de localités et l'on se propose de rechercher celles dont le nom de termine par ville.
On ne distingue pas les majuscules et les minuscules dans la recherche.
import re
texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmayé-sur-Orne\\
\\nAmblie\\nAmfreville\\nAngervillers\\nAngoville\\nArganchy\\nArgences\\
\\nArromanches-les-Bains\\nAsnelles\\nAsnières-Surville\"
print(\"le texte\",texte,\"\\n\")
patron = \".*ville$\"
cpatron = re.compile (patron)
resultat = cpatron.findall(texte)
print (\"exemple 1: \",resultat, \"\\n\")
cpatron = re.compile (patron, re.MULTILINE)
resultat = cpatron.findall(texte)
print (\"exemple 2: \",resultat, \"\\n\")
cpatron = re.compile (patron, re.MULTILINE+re.IGNORECASE)
resultat = cpatron.findall(texte)
print (\"exemple 3: \",resultat, \"\\n\")
Ecrire et tester le code.
Justifier les résultats.
","title":"Des méthodes à recherches multiples"},{"edit":"Ecrire ici les résultats.
La syntaxe est la suivante :
cpatron.sub (remplacement, texte, [count])
Retourne le texte avec ses remplacements.
La valeur remplacement est une chaîne (qui peut être obtenue par application d'une fonction, appelée à chaque remplacement).
count fixe le nombre maximum de remplacements ; 0 est la valeur par défaut et signifie (paradoxalement) que tous les remplacements possibles doivent être effectués.
On a aussi la syntaxe :
cpatron.subn (remplacement, texte, count)
Renvoie un tuple comportant la nouvelle chaîne et le nombre de remplacements.
Application :
# substitution dans une chaîne
import re
texte = \"Retourne le texte avec ses remplacements. La \\
valeur remplacement est une chaîne (qui peut être obtenue \\
par application d'une fonction, appelée à chaque \\
remplacement). count donne le maximum de remplacements ; \\
0 est la valeur par défaut et signifie que tous les remplacements\\
possibles doivent être effectués.\"
print(\"le texte\",texte,\"\\n\")
patron= \"\\. \" # antislash de protection du point
remplacement =\"\\n\\n\"
cpatron = re.compile(patron)
nouveau = cpatron.sub(remplacement, texte)
print (nouveau)
print (\"\\n************************************\\n\")
retTuple = cpatron.subn (remplacement, texte)
print (retTuple)
Ecrire et tester le code.
Justifier les résultats.
Ecrire ici les résultats.
La syntaxe est la suivante :
cpatron.split(texte, [maxsplit])
Pour mémoire, reprenons l'application 1 avec split() au lieu de findall()
import re
texte =\"Ablon\\nAcqueville\\nAgy\\nAigner-Ville\\nAiran\\nAmayé-sur-Orne\\
\\nAmblie\\nAmfreville\\nAngervillers\\nAngoville\\nArganchy\\nArgences\\
\\nArromanches-les-Bains\\nAsnelles\\nAsnières-Surville\"
print(\"le texte\",texte,\"\\n\")
patron = \".*ville$\"
cpatron = re.compile(patron)
resultat = cpatron.split(texte)
print (\"exemple 1: \",resultat, \"\\n\")
cpatron = re.compile (patron, re.MULTILINE)
resultat = cpatron.split(texte)
print (\"exemple 2: \",resultat, \"\\n\")
cpatron = re.compile (patron, re.MULTILINE+re.IGNORECASE)
resultat = cpatron.split(texte)
print (\"exemple 3: \",resultat, \"\\n\")
Ecrire et tester le code.
Justifier les résultats par rapport à la fonction findall().
Ecrire ici les résultats.
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 : 1298
[[{"text":"Remplir les champs ci-dessous :","title":"Python : Les expressions régulières","posi":0},{"edit":"Nom : "},{"edit":"Prénom : "},{"edit":"Classe : "},{"text":"
","title":"Poser le problème."},{"edit":"
"}],[{"text":"
"}],[{"text":"
Ecrire ici le résultat.
"}],[{"text":"
","title":"Remplacer."},{"edit":"
Répondre ici.
"}],[{"text":"
","title":"Exercices"},{"edit":"
","title":"Découper."},{"edit":"
","title":"Exercice"},{"edit":"
"}],[{"text":"
","title":"Les «expressions régulières »"},{"edit":"
"}],[{"text":"
"},{"edit":"
Ecrire ici vos résultats.
","css":"","js":""}],[{"text":"
","title":"La fonction dir"},{"edit":"
"}],[{"text":"
","title":"compiler le patron."},{"edit":"
"}],[{"text":"
","title":"L'héritage de classe"},{"edit":"
Ecrire ici les résultats.
"}],[{"text":"
","title":"les jokers et marqueurs fondamentaux"},{"edit":"Ecrire ici les résultats.
"}],[{"text":"
","title":"consommation"},{"edit":"
","title":"gourmandise."},{"edit":"
"}],[{"text":"
","title":"échappement"},{"edit":"
"}],[{"text":"
Source : https://python.doctor/page-apprendre-programmation-orientee-objet-poo-classes-python-cours-debutants ","title":"Envoyer votre travail"},{"edit":"
"}]]
Source de l'image :
"}],[{"text":"On dispose d'un texte, c'est à dire pour Python d'une chaîne de caractères (string).
Par ailleurs, on propose d'un motif, qui est lui aussi une chaîne de caractères.
Le problème consiste à détecter la présence du motif dans le texte, et éventuellement de remplacer ce motif par un autre..
Nous avons des fonctions définies oar python.
str.find(sub[, start[, end]])
retourne le premier indice de la chaîne où la sous-chaîne sub est trouvée ; si start et end sont précisés, le domaine de recherche est la sous-chaîne formée des caractères dont l'indice est entre les valeurs de start et de end (la tranche commence avec start et se termine avant end). La méthode retourne -1 en cas d'échec de la recherche.
str.index(sub[, start[, end]])
comme find(), mais lève une exception ValueError si la sous-chaîne n'est pas trouvée.
Cela permet de programmer les ruptures de séquences avec des exceptions. str.rfind(sub[, start[, end]])
comme find(), mais commence par la fin de la chaîne.
str.rindex(sub[, start[, end]])
comme rfind() mais lève une exception ValueError si la sous-chaîne n'est pas trouvée.
str.count(sub[, start[, end]])
retourne le nombre d'occurrences de la sous-chaîne sub dans la tranche [start,end]
","title":"Trouver"},{"edit":"On a la chaine de caractère suivante :
texte = \"\"\"Un IDE ou environnement de développement est un logiciel constitué d'outils qui facilitent l'écriture et les tests dans un ou plusieurs langages de programmation.
Cet IDE comporte en général un éditeur avec coloration syntaxique,
un système de gestion de fichiers (sauvegarde/chargement),
un compilateur, un exécuteur de programme, un système d'aide en ligne,\\
des indicateurs de syntaxe etc.
Le plus connu est peut être Éclipse.
\"\"\"
# première occurence du motif / numérotation qui commence à 0
motif = \"IDE\"
resultat = texte.find(motif)
print (\"première occurence du motif :\", resultat)
# nombre d'occurrences du motif
resultat= texte.count (motif)
print (\"nombre d'occurrences du motif :\",resultat)
# recherche d'un motif avec problème de casse
motif = \"éclipse\"
resultat = (texte.upper()).find(motif.upper())
print (motif, \"est présent comme\",texte[resultat:resultat+len(motif)])
résultat :
","title":"Exercice"},{"edit":"ce que dit la documentation.
str.replace(old, new[, count])
retourne une copie de la chaîne où toutes les occurrences de la sous-chaîne old sont remplacées par la chaîne new. Si la valeur count est précisée, seules les count premières occurrences sont remplacées.
3.2. un exemple.
>>>
première occurrence du motif : 3
nombre d'occurrences du motif : 2
éclipse est présent comme Éclipse
>>>
#!/usr/bin/python3
# remplacer dans une chaîne
texte = \"Un IDE ou \\\"environnement de développement\\\" est un logiciel \\
E.R. en Python 3
fiche 0 : trouver et remplacer dans une chaîne.
page 4
constitué d'outils qui facilitent l'écriture et les tests dans un \\
langage défini, voire plusieurs.\\
\\nCet IDE comporte en général un éditeur avec coloration syntaxique,\\
un système de gestion de fichiers (sauvegarde/chargement),\\
un compilateur, un exécuteur de programme, un système d'aide en ligne,\\
des indicateurs de syntaxe etc. \\
\\nLe plus connu est peut être Éclipse.\"
# remplacement
motif = \"\\n\"
resultat = texte.replace(motif, \" \")
print (resultat)
résultat :
>>>
Un IDE ou \"environnement de développement\" est un logiciel constitué
d'outils qui facilitent l'écriture et les tests dans un langage défini,
voire plusieurs. Cet IDE comporte en général un éditeur avec coloration
syntaxique,un système de gestion de fichiers (sauvegarde/chargement),un
compilateur, un exécuteur de programme, un système d'aide en ligne,des
indicateurs de syntaxe etc. Le plus connu est peut être Éclipse.
>>>
Ecrire les résultats ici.
"}],[{"text":" 4. Découper.
4.1. ce que dit la documentation.
str.split([sep[, maxsplit]])
retourne une liste de mots de la chaîne, en utilisant sep comme délimiteur. Si maxsplit est
donné, il y a au plus maxsplit coupures (et la liste a au plus maxsplit+1 éléments).
En l'absence de séparateur spécifié, ou avec le séparateur None, l'espace est considéré
comme séparateur.
str.splitlines([keepends])
retourne une liste des lignes de la chaîne. En principe, le séparateur de ligne n'est pas gardé, sauf si keepend est posé à True.
Ecrire les résultats ici.
"}],[{"text":"4.2. exemples.
#!/usr/bin/python3
# couper une chaîne
texte = \"123,,456,\"
# split
liste = texte.split (\",\")
print (\"texte :\",texte, \"\\nliste :\", liste,\"\\n\\n\")
# splitline
texte = \"\\nABC\\nDEF\\nGHI\"
liste = texte.splitlines()
print (\"texte :\",texte, \"\\nliste :\", liste,\"\\n\\n\")
E.R. en Python 3
fiche 0 : trouver et remplacer dans une chaîne.
page 5
# splitline avec keepend
texte = \"\\nABC\\nDEF\\nGHI\"
liste = texte.splitlines(True)
print (\"texte :\",texte, \"\\nliste :\", liste,\"\\n\\n\")
résultats :
>>>
texte : 123,,456,
liste : ['123', '', '456', '']
texte :
ABC
DEF
GHI
liste : ['', 'ABC', 'DEF', 'GHI']
texte :
ABC
DEF
GHI
liste : ['\\n', 'ABC\\n', 'DEF\\n', 'GHI']
>>>
E.R. en Python 3
fiche 0 : trouver et remplacer dans une chaîne.
page 6
Ecrire les résultats ici.
Les «expressions régulières » en Python 3 peuvent être abordées à l'aide du module re :
import re # module des expressions régulières
Les fichiers du module re.py, re.pyc, re.pyo, respectivement le fichier source, le fichier compilé, le fichier optimisé se trouvent dans le répertoire des librairies Lib, à la racine. Il n'y a donc aucun problème particulier pour son utilisation. C'est là que la machine Python cherche les modules (après le répertoire actuel, évidemment).
Dans les fiches qui suivent, on utilise l'importation sous la forme import ; il faut donc qualifier systématiquement les éléments constitutifs du module. En production, il se peut qu'il soit intéressant, pour éviter des lourdeurs de code, d'utiliser la forme from... import et de définir des alias. C'est évidemment tout à fait possible, mais ce n'est pas ici le lieu d'en discuter.
Ecrire ici vos résultats.
1. Matching et Searching. 1.1. vocabulaire.
Pour la clarté de l'exposé, nous traduirons le verbe to match par correspondre à, et to search par rechercher et donc matching par correspondance et searching par recherche. Il ne faut pas chercher de signification \"intuitive\" à ces concepts qui ont dans chacun des langages comme C, Java ou Python un sens précis, mais malheureusement pas le même d'un langage à l'autre.
Ecrire ici vos résultats.
1.2. poser le problème.
Problème : On dispose d'un texte, c'est à dire pour Python une chaîne de caractères ; par ailleurs, on propose un patron (ou motif), qui est lui aussi une chaîne de caractères. Le problème consiste à détecter une sous-chaîne respectant le patron dans le texte et éventuellement à remplacer par une chaîne prédéfinie la (ou les) sous-chaînes(s) trouvées. D'autres opérations sont possibles, qui seront vues en leur temps.
Le texte se présente sous forme d'une chaîne de caractères en mémoire vive (variable, chaîne littérale) ; on ne se pose pas de problème d'encodage (UNICODE par défaut en version 3 ; en versions 2.x, le code est le code local. On peut définir la norme de l'encodage par une clause -code-). Si on dispose d'un fichier de texte, le problème de l'encodage se pose lors du chargement !
Le patron est pour l'instant une chaîne, avec quelques problèmes : comme d'habitude, les sauts de lignes sont codés \\n, l'antislash est codé \\\\. L'antislash protège les quotes. Mais il doit aussi protéger un certain nombre de caractères usuels comme le point, ^, $, + , ?, * . Cela sera explicité plus complètement dans les fiches qui suivent.
Ecrire ici le résultat.
1.3. compiler le patron.
La syntaxe est la suivante :
cpatron = re.compile(patron, directives)
Le type (classe) de cpatron est : '_sre.SRE_Pattern'
_sre est le module appelé dans le module re ; SRE_Pattern est le nom de la classe.
Les directives se présentent sous forme d'un entier : chaque directive est une puissance de deux, et le paramètre directives est la somme de directives particulières.
E.R. en Python 3
fiche 1 : le module Python RE
page 7
constante
abrégé
valeur
signification
IGNORECASE
I
2
ignorer la casse ; fonctionne avec les lettres accentuées
LOCALE
L
4
définir comme \"lettre\" ce que la langue locale définit comme tel dans la variable système.;
MULTILINE
M
8
considèrer le texte comme décomposé en lignes (le caractère \\n est le début de chaque ligne)
DOTALL
S
16
considèrer le saut de ligne comme un caractère ordinaire.
UNICODE
U
32
obsolète dans Python 3
VERBOSE
X
64
permettre d'écrire des commentaires dans les patrons.
ASCII
A
256
permettre de travailler en ASCII
On peut écrire indifféremment re.IGNORECASE+re.MULTILINE ou re.I+re.M
En pratique, dans le début du travail, seules les directives IGNORECASE, MULTILINE et DOTALL
sont à prendre en compte. On verra plus tard la directive VERBOSE. 1.4. comparer et chercher.
* La syntaxe des fonctions est la suivante :
cpatron.search (texte)
cpatron.match (texte)
* La recherche (search()) consiste à parcourir le texte depuis le début ; si le patron n'est pas identifiable dans le texte, la fonction retourne None. Sinon, elle retourne une instance de l'objet MatchObject, appartenant lui aussi au module _sre.
La comparaison (match()) consiste à identifier le début du texte au patron. Elle retourne None si aucune comparaison n'est possible. Sinon elle retourne une instance MatchObject.
* l'objet : MatchObject
Cet objet peut être interrogé par ses méthodes. Pour l'instant, les méthodes start() (premier caractère reconnu) et stop() (position après le dernier caractère reconnu)
#!/usr/bin/python3
import re
texte = \"Un IDE ou \\\"environnement de développement\\\" est un logiciel \\
constitué d'outils qui facilitent l'écriture et les tests dans un \\
langage défini, voire plusieurs.\\
\\nCet IDE comporte en général un éditeur avec coloration syntaxique,\\
un système de gestion de fichiers (sauvegarde/chargement),\\
un compilateur, un exécuteur de programme, un système d'aide en ligne,\\
des indicateurs de syntaxe etc. \\
\\nLe plus connu est peut être Éclipse.\"
# recherche du patron dans le texte ; résultat affiché : 158 165
patron = \"Cet IDE\"
cpatron = re.compile(patron)
resultat = cpatron.search(texte)
E.R. en Python 3
fiche 1 : le module Python RE
page 8
if resultat :
print (resultat.start(), resultat.end())
else:
print (resultat)
# comparaison du patron au texte ; résultat affiché : None
resultat = cpatron.match(texte)
if resultat :
print (resultat.start(), resultat.end())
else :
print (resultat)
# comparaison du patron au texte ; résultat affiché : 0 6
patron = \"Un IDE\"
cpatron = re.compile (patron)
resultat = cpatron.match(texte)
if resultat :
print (resultat.start(), resultat.end())
else :
print (resultat)
# recherche en ignorant la casse ; résultat affiché : 413 420
patron = \"éclipse\"
cpatron = re.compile (patron, re.IGNORECASE)
resultat = cpatron.search(texte)
if resultat :
print (resultat.start(), resultat.end())
else:
print (resultat)
note. Il existe plusieurs présentations syntaxiques pour les méthodes comme search(). Dans le script ci-dessus, search() est une méthode de l'objet SRE_Pattern. Mais Python l'a également redéfini comme une fonction du module re :
exemple : re.search(patron, texte, re.IGNORECASE))...
Pour la clarté de l'exposé, on s'en tient à une seule syntaxe, celle du script ci-dessus, qui a l'avantage
de ressembler à ce qui se fait en java.
Ecrire ici le résultat.
2. Expression régulière.
2.1. remarques sur la section précédente.
La section qui précède a pour objectif de spécifier une syntaxe : celle requise par le module re pour faire des opérations assez semblables à celles réalisées avec plus de simplicité par les méthodes de la classe str.
Quel est l'apport du module re pour les opérations de recherche, de comparaison, de substitution, de découpage de chaînes ? Lorsque l'on fait une recherche ou une substitution dans un traitement de texte ou un éditeur, la chaîne recherchée doit être explicite. On peut imposer de ne pas différencier majuscules et minuscules, ou de ne rechercher que des mots entiers ; ces aménagements sont insuffisants.
note : les éditeurs et traitements de texte actuels peuvent travailler différemment !
On peut souhaiter disposer, pour écrire les patrons, de jokers (comme le * ou le ? dans les shells des
E.R. en Python 3
fiche 1 : le module Python RE
page 9
systèmes d'exploitation) ou de conditions (exemple : trouver les virgules qui sont suivies d'un caractère alphabétique ; trouver les espaces multiples ; se limiter aux caractères alphanumériques). Les expressions régulières sont des chaînes comportant des jokers et des éléments de description de chaînes de caractères.
2.2. les jokers et marqueurs fondamentaux.
signe
signification générale
signification sous directive
.
le point remplace tout caractère sauf le saut de ligne (\\n).
sous DOTALL, le point représente tout caractère, y compris le saut de ligne.
^
Le chevron (circonflexe) représente le début de la chaîne analysée.
sous MULTILINE, représente en plus la position après le saut de ligne
$
Le dollar représente la fin de la chaîne analysée.
sous MULTILINE, représente en plus la position avant le saut de ligne.
exemples d'expressions régulières :
\"azer.tyiop\" : cette expression régulière correspond à : azer suivi de n'importe quel
caractère, suivi de tyiop sur une ligne. En mode DOTALL, le caractère peut être le saut de ligne.
En recherche, azeratyiop, azerAtyiop, azer(tyiop, azer.tyiop satisfont au
modèle proposé.
\"^aze\" : le patron \"aze\" doit être recherché en début de texte uniquement en début de texte.
En mode MULTILINE, il est aussi recherché en début de chaque ligne. \"tyiop$\" : le patron \"tyiop\" est recherché en fin de texte.
En mode MULTILINE, il est aussi recherché en fin de chaque ligne. \"^$\" : recherche d'un texte vide ou en mode MULTILINE d'une ligne vide.
2.3. répétitions d'un caractère.
itérateur
interprétation
*
zéro, une ou plusieurs fois le caractère qui précède
+
une ou plusieurs fois le caractère qui précède
?
zéro ou une fois le caractère qui précède
{m}
exactement m fois le caractère qui précède
{m,}
au moins m fois le caractère qui précède
{m,n}
au moins m fois et au plus n fois le caractère qui précède
exemples :
exp. reg.
chaînes reconnues
ab*c
ac, abc, abbc, abbbc, ...
ab+c
abc, abbc, abbbc, ...
E.R. en Python 3
fiche 1 : le module Python RE
page 10
ab?c
ac, abc
ab{2,}c
abbc, abbbc, abbbbc, ....
ab{2,4}c
abbc, abbbc, abbbbc
2.4. consommation.
Lorsqu'une recherche est couronnée de succès, la partie de la chaîne comprise entre le début de celle-ci et la fin de la sous-chaîne trouvée est consommée. Ce qui signifie par exemple que la fonction findall() commence la recherche à partir du caractère suivant le dernier caractère consommé. La recherche est séquentielle et elle ne fait aucun retour en arrière.
Ecrire ici les résultats.
"}],[{"text":"2.5. gourmandise.
les itérateurs *, +, ? sont gourmands. C'est-à-dire que dans une recherche, ils ont un comportement qui conduit à reconnaître la plus grande chaîne possible. Ils consomment la chaîne au maximum, même si une correspondance a déjà été trouvée sur le patron proposé.
Par exemple, supposons que l'on ait :
texte = \"<h1>Expressions Régulières</h1>\"
patron = \"<.*>\"
Le sous-motif .* conduit à avoir le plus grand texte possible : l'expression régulière s'identifie à tout le texte. Il faut lire patron comme :
le caractère < pour commencer ; un maximum de caractères ; le caractère > pour finir. On aurait pu souhaiter au contraire une identification à <h1>, c'est-à-dire :
le caractère < pour commencer ; un minimum de caractères ; le caractère >. Une nouvelle classe d'itérateurs réalisent ces opérations :
itérateur
interprétation
*?
zéro, une ou plusieurs fois le caractère qui précède ; non gourmand. Dans une expression, *? s'identifie à la plus petite chaîne possible.
+?
une ou plusieurs fois le caractère qui précède ; non gourmand.
??
zéro ou une fois le caractère qui précède ; non gourmand.
{m,n}?
le caractère qui précède m fois.
exemple :
import re
texte = \"<<aaAAabbbccaaannn\"
patron = \"a{2,3}b?\"
cpatron = re.compile(patron, re.I)
res = cpatron.findall(texte)
print (\"patron :\",patron,\"résultat : \",res)
patron = \"a{2,3}?b?\"
cpatron = re.compile(patron, re.I)
E.R. en Python 3
fiche 1 : le module Python RE
page 11
res = cpatron.findall(texte)
print (\"patron :\",patron,\"résultat : \",res)
patron = \"a{2,3}b??\"
cpatron = re.compile(patron, re.I)
res = cpatron.findall(texte)
print (\"patron :\",patron,\"résultat : \",res)
résultat :
Pour bien comprendre, il faut simuler la consommation !!!
Ecrire ici les résultats.
2.5. échappement.
Les jokers et les opérateurs sont des caractères courants. Comment, dans une expression régulière peut-on distinguer ce caractère en tant que caractère et le même en tant qu'opérateur ou composant d'un opérateur ? On utilise le même système que Python dans ce cas : pour considérer un caractère comme se représentant lui-même, il faut l'échapper par un antislash. On aura donc pour le point \\., pour l'astérisque \\*, pour le signe plus \\+ et ainsi de suite. Cela peut se compliquer ; un chapitre spécial sera consacré à cette question.
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 : 1313
[[{"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":"
Source : https://www.leptidigital.fr/reseaux-sociaux/liste-reseaux-sociaux-14846/
"}],[{"text":"
"}],[{"quiz":830}],[{"textnp":"
![](\"https://sciencesappliquees.com/images/snt/tabdist.png\")
","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/"}]]
Source : https://www.leptidigital.fr/reseaux-sociaux/liste-reseaux-sociaux-14846/
Regardez la vidéo.
En cas de pproblème, suivre le lien suivant :
https://youtu.be/58Ou5KVfrEk
"},{"edit":" 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 : 1200
[[{"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\")
","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 : 1474