Regular expressions: groups and testing

Groups: taking out parts

Parentheses mark a groupgroupA part of a pattern in parentheses. The text it fits can be taken out on its own: .group(1), or the tuples findall returns.: a part you want to take out on its own. Predict:

import re
print(re.findall(r"(\d+)-(\d+)", "10-20 30-40"))

[('10', '20'), ('30', '40')]

With search, .group(1) is the first group and .group() is still the whole match. On lesson 6.2's payment message, one pattern replaces the find and slice work (\. is a real full stop). The Mawj bot reads payment messages with patterns like this.

import re

sms = "Paid ETB 250.00 to Selam Coffee. Transaction ID: DF12GH34."
found = re.search(r"ETB (\d+\.\d+)", sms)
print(found.group(1))

Groups are numbered by their opening parentheses, left to right. Ask for one the pattern doesn't have and Python says so:

Greedy patterns

One more surprise. Predict both lines:

import re
print(re.findall(r"<.*>", "<a><b>"))
print(re.findall(r"<.*?>", "<a><b>"))

['<a><b>']
['<a>', '<b>']

* and + are greedygreedyTaking as much text as possible while the pattern still fits. * and + are greedy; *? and +? take as little as possible.: they take as much text as they can. *? and +? take as little as they can. On the payment message, to (.*)\. gives Selam Coffee. Transaction ID: DF12GH34, because .* runs on to the last full stop; to (.*?)\. stops at the first and gives Selam Coffee.

Building and testing a phone pattern

Ethiopian mobile numbers start with 09 (Ethio Telecom) or 07 (Safaricom Ethiopia), then eight more digits: 0[79]\d{8}. From abroad, +251 replaces the 0. | means "or", and (?:...) groups without capturing, so findall still returns whole numbers:

(?:\+251|0)   +251 or 0 (\+ is a real plus sign)
[79]          then 7 or 9
\d{8}         then exactly eight digits

A pattern is only as good as its tests, and the useful tests are the numbers that should fail:

import re

PHONE = r"(?:\+251|0)[79]\d{8}"
tests = ["0911234567", "+251712345678", "0811234567", "091123456",
       "09112345678", "+2510911234567", "0911 234 567", "O911234567"]
for number in tests:
  print(number, bool(re.fullmatch(PHONE, number)))

The first two should pass. Every other one is a real typing mistake: a prefix no operator uses, a digit short, a digit extra, +251 with the 0 kept, spaces, and a capital O typed for a zero. (08 is kept for a third operator. If one starts using it, the pattern becomes [789], and that test changes.) Change fullmatch to search and run it again: the two long ones pass, because search finds ten good digits inside them.

To pull numbers out of a message, findall with the same pattern:

import re

PHONE = r"(?:\+251|0)[79]\d{8}"
msg = "Call Hana on 0911234567 or Abel on +251712345678, not 0811234567."
print(re.findall(PHONE, msg))

When startswith, in, or split can do the job, use them instead. number.startswith(("09", "07")) from lesson 6.1 needs no explaining; a regex always does.