Discussion :

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Sve@r]

Bonjour

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

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

[Invité]

Slt !
Avec re :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[pitchu]

merci de vos aides

[MPython Alaplancha]

Bonjour,

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[jurassic pork]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

é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

[MPython Alaplancha]

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

[wiztricks]

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

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.

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

[MPython Alaplancha]

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
D'ailleurs après test,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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é...