regex: extraire le troisième élément en partant de la fin d'une URL

Bonjour,

Je voudrais savoir comment récupérer le troisième élément en partant de la fin dans une url:
Par exemple:

Code:

---

1 2 3 4 5 6

import re >>> url = "vfzefqzd/qzdqzdq/qdzqdqa/qdaqd/élement/fqefqqf/efqfq >>> pattern = "" >>> reg = re.search(pattern, next_page_url) >>> print(reg) >>> élement

---

Bonjour

Citation:

---

Envoyé par pitchu

Je voudrais savoir comment récupérer le troisième élément en partant de la fin dans une url:

---

reg=url.split("/")[-3]

Slt !
Avec re :

Code:

---

re.split(r'/', url)[-3]

---

merci de vos aides

Bonjour,

Citation:

---

Envoyé par pitchu

Bonjour,

Je voudrais savoir comment récupérer le troisième élément en partant de la fin dans une url:
Par exemple:

Code:

---

1 2 3 4 5 6

import re >>> url = "vfzefqzd/qzdqzdq/qdzqdqa/qdaqd/élement/fqefqqf/efqfq >>> pattern = "" >>> reg = re.search(pattern, next_page_url) >>> print(reg) >>> élement

---

---

Code:

---

1 2 3 4 5 6

>>> url = "vfzefqzd/qzdqzdq/qdzqdqa/qdaqd/élement/fqefqqf/efqfq" >>> pat = r"(\w*)/\w*/\w*$" >>> reg = re.search(pat, url) >>> reg.group(1) 'élement' >>>

---

Hello,
il est à noter que quand cela est possible (comme dans le cas présent) un split chaîne est plus écologique (moins de consommation CPU) que l'utilisation des expressions régulières. Voici un test de performance avec les 3 méthodes proposées précédemment :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import re from time import perf_counter_ns url = "vfzefqzd/qzdqzdq/qdzqdqa/qdaqd/élement/fqefqqf/efqfq" pat = r"(\w*)/\w*/\w*$" start = perf_counter_ns() reg=url.split("/")[-3] stop = perf_counter_ns() print(reg) print("temps écoulé pour url.split : " + str(stop-start) + " ns") print("=========================================") start = perf_counter_ns() re.split(r'/', url)[-3] stop = perf_counter_ns() print(reg) print("temps écoulé pour re.split : " + str(stop-start) + " ns") print("=========================================") start = perf_counter_ns() reg = re.search(pat, url) stop = perf_counter_ns() print(reg.group(1)) print("temps écoulé pour re.search : " + str(stop-start) + " ns")

---

Résultat :

Citation:

---

élement
temps écoulé pour url.split : 1400 ns
=========================================
élement
temps écoulé pour re.split : 84900 ns
=========================================
élement
temps écoulé pour re.search : 104800 ns

---

Ami calmant, J.P

Bonjour,

à noter aussi qu'avec une expression rationnelle, si l'expression est amenée à être utilisée plusieurs fois, il est préférable en termes de vitesse d'exécution d'utiliser re.compile().

Citation:

---

Envoyé par Hominidé

Bonjour,

à noter aussi qu'avec une expression rationnelle, si l'expression est amenée à être utilisée plusieurs fois, il est préférable en termes de vitesse d'exécution d'utiliser re.compile().

---

C'est plus compliqué que çà (source):

Citation:

---

The compiled versions of the most recent patterns passed to re.compile() and the module-level matching functions are cached, so programs that use only a few regular expressions at a time needn’t worry about compiling regular expressions.

---

Citation:

---

Envoyé par jurassic pork

il est à noter que quand cela est possible (comme dans le cas présent) un split chaîne est plus écologique (moins de consommation CPU) que l'utilisation des expressions régulières.

---

Ce qui est logique car traiter une expression régulière nécessite la mise en place et l'exécution d'un automate dont les complexités seront indépendantes de l'expression: simple ou complexe, c'est parti pour faire le même boulot.

- W

Citation:

---

Envoyé par wiztricks

C'est plus compliqué que çà (source):

- W

---

J'en comprends ce que j'en ai dit, mais peut être j'interprète mal ce que je lis :roll:
D'ailleurs après test,

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

import re from time import perf_counter_ns url = "vfzefqzd/qzdqzdq/qdzqdqa/qdaqd/élement/fqefqqf/efqfq" pat = r"(\w*)/\w*/\w*$"   start = perf_counter_ns() reg = re.search(pat, url) stop = perf_counter_ns() print(reg.group(1)) print(f"temps écoulé pour re.search : {stop-start} ns")   start = perf_counter_ns() pat = re.compile(pat) reg = pat.search(url) stop = perf_counter_ns() print(f"temps écoulé pour re.compile/re.search : {stop-start} ns")   start = perf_counter_ns() pat = re.compile(pat) for _ in range(1000): reg = pat.search(url) stop = perf_counter_ns() print(f"temps écoulé pour re.search/re.compile; loop:1000:{stop-start} ns")

---

il semble profitable de compiler l'expression rationnelle même pour une seule utilisation (7.8 plus rapide). Utilisée dans une boucle de 1000 loops, l'exécution de re.search() devient 20 fois plus rapide. Je m'attendais, à la lecture de la doc de Re, qu'utiliser re.compile() pour une seule utilisation de l'expression n'était pas utile/encouragé...

Salut,

Citation:

---

Envoyé par Hominidé

il semble profitable de compiler l'expression rationnelle même pour une seule utilisation (7.8 plus rapide).

---

Ce que dit la documentation est qu'un pattern sera compilé et mis dans un cache qui garde les dernières expression régulières utilisées.
Donc ce qu'on devrait comparer, c'est la différence entre "je fais le boulot en amont":

Code:

---

1 2 3

pattern = 'mon expression régulière' cp = re.compile(pattern) re.search(cp,...)

---

et "je le sous traite" à re.search (ou autre) via un appel direct:

Code:

---

1 2	pattern = 'mon expression régulière' re.search(pattern,...)

---

Et ce qu'on va mesurer, c'est la mise en cache pour rien puisqu'à priori je n'utilise pattern qu'une seule fois.
Et si on fait plusieurs appels dans une boucle, on devrait comparer "je fais le boulot":

Code:

---

1 2 3 4 5 6

pattern = 'mon expression régulière' cp = re.compile(pattern) for s in ...: ... re.search(cp, s) ...

---

a "je délègue":

Code:

---

1 2 3 4 5

pattern = 'mon expression régulière' for s in ...: ... re.search(pattern, s) ...

---

ou là on mesure la mise en cache à a première itération appel et la récupération du pattern compilé du cache les itérations suivantes.

Et ce qu'on mesure, c'est l'intérêt du cache géré par le module RE vs. mettre en cache soi même et à priori, il y aura une différence mais on s'attend à des pou^ièmes pas à un facteur 10.

Après ce que dit la documentation est que ce cache ne garde que quelques patterns compilés "récents" (voir le lru_cache). Donc, avec un programme qui utilise "beaucoup" d'expressions régulières a différents endroits, il y a peut être intérêt à créer son propre cache.

Est-ce plus clair?

- W

Citation:

---

Est-ce plus clair?

- W

---

Oui. Merci.