Extract string with Python re.match

Question

import re
str="x8f8dL:s://www.qqq.zzz/iziv8ds8f8.dafidsao.dsfsi"
str2=re.match("[a-zA-Z]*//([a-zA-Z]*)",str)
print str2.group()
current result=> error
expected => wwwqqqzzz

I want to extract the string wwwqqqzzz. How I do that?

Maybe there are a lot of dots, such as:

"whatever..s#[email protected].:af//wwww.xxx.yn.zsdfsd.asfds.f.ds.fsd.whatever/123.dfiid"

In this case, I basically want the stuff bounded by // and /. How do I achieve that?

One additional question:

import re
str="xxx.yyy.xxx:80"
m = re.search(r"([^:]*)", str)
str2=m.group(0)
print str2
str2=m.group(1)
print str2

Seems that m.group(0) and m.group(1) are the same.

• danseery: do you want dots to be removed from the final string?
• runcode: yes, i just want purely characters [a-zA-Z]* between //and /, before '//' has bunch characters, also after '/' at the end,

Answer 1

match tries to match the entire string. Use search instead. The following pattern would then match your requirements:

m = re.search(r"//([^/]*)", str)
print m.group(1)

Basically, we are looking for /, then consume as many non-slash characters as possible. And those non-slash characters will be captured in group number 1.

In fact, there is a slightly more advanced technique that does the same, but does not require capturing (which is generally time-consuming). It uses a so-called lookbehind:

m = re.search(r"(?<=//)[^/]*", str)
print m.group()

Lookarounds are not included in the actual match, hence the desired result.

This (or any other reasonable regex solution) will not remove the .s immediately. But this can easily be done in a second step:

m = re.search(r"(?<=//)[^/]*", str)
host = m.group()
cleanedHost = host.replace(".", "")

That does not even require regular expressions.

Of course, if you want to remove everything except for letters and digits (e.g. to turn www.regular-expressions.info into wwwregularexpressionsinfo) then you are better off using the regex version of replace:

cleanedHost = re.sub(r"[^a-zA-Z0-9]+", "", host)

• Martin Ender: sorry, I just saw that requirement. simply run another step: resultstr.replace(r".", ""). Will include that in a second.
• lqc: "there is a slightly more advanced technique that does the same, but does not require capturing (which is generally time-consuming). It uses a so-called lookbehind" - Do you have anything to back this up? Both my intuition and timeit tell me that lookbehinds are slower then a simple group capture.
• runcode: what does it mean by group(0) ,group(1), seems group(0) result same as group(1) in my case, added on question
• Martin Ender: @runcode group(0) gives you the complete match. group(1) gives you what was matched with everything inside the first set of parentheses. in your example you wrapped your whole pattern in parentheses. hence, both calls give the same result.
• Martin Ender: @lqc, I don't have any source at hand no. I believe it mostly applies for more complex patterns, where things would be captured multiple times. after all, the engine needs to keep track of what was matched since it entered a capturing group. In any specific case, the lookbehind might be less efficient, I admit.

Answer 2

print re.sub(r"[.]","",re.search(r"(?<=//).*?(?=/)",str).group(0))

See this demo .

Answer 3

output=re.findall("(?<=//)\w+.*(?=/)",str)
final=re.sub(r"[^a-zA-Z0-9]+", "", output [0])
print final

Answer 4

import re
str_1="x8f8dL:s://www.qqq.zzz/iziv8ds8f8.dafidsao.dsfsi"
str2=re.match(".*//([a-zA-Z.]*)",str_1)
print(str2.group(1).replace('.',''))

• Dharman: While this code may solve the question, including an explanation of how and why this solves the problem would really help to improve the quality of your post, and probably result in more up-votes. Remember that you are answering the question for readers in the future, not just the person asking now. Please edit your answer to add explanations and give an indication of what limitations and assumptions apply.

Answer 5

import re
str="x8f8dL:s://www.qqq.zzz/iziv8ds8f8.dafidsao.dsfsi"
re.findall('//([a-z.]*)', str)

• BDL: Although the code might solve the problem, it is not an answer on its own. One should always add an explanation to it.