Учебный пример: Обработка телефонных номеров

\d совпадает с любыми цифрами (0–9). \D совпадает со всем кроме цифр

До сих пор вы были сконцентрированы на полных патернах. Совпадает патерн или не совпадает, но регулярные выражения могут быть гораздо мощнее этого. Когда регулярное выражение совпадает с чем либо, вы можете получить специально выделенную часть совпадения. Вы можете узнать что совпало и где.

Этот пример появился из ещё одной реальной проблемы которые я испытывал на предыдущей работе. Проблема была в обработке американских телефонных номеров. Клиент хочет ввести телефонный номер в простое поле (без разделителей), но потом также хочет сохранить индекс, магистраль, номер и опционально добавочную информацию в базе данных компании. Я поискал по интернет и нашёл много примеров регулярного выражения которое должно делать это, но к сожалению ни одно из решений не подошло.

Вот телефонные номера которые я должен был обработать:

• 800-555-1212
• 800 555 1212
• 800. 555. 1212
• (800) 555-1212
• 1-800-555-1212
• 800-555-1212-1234
• 800-555-1212x1234
• 800-555-1212 ext. 1234
• work 1-(800) 555. 1212 #1234

Достаточно вариантов в любом из этих примеров. Мне необходимо было знать код 800, магистраль 555 и остаток номера 1212. Для тех что с расширениями, мне необходимо было знать что расширение 1234

Давайте займёмся разработкой решения для обработки телефонного номера. Этот пример показывает первый шаг:

 

> > > phonePattern = re. compile(r'^(\d{3})-(\d{3})-(\d{4})$') ①
> > > phonePattern. search('800-555-1212'). groups() ②
('800', '555', '1212')
> > > phonePattern. search('800-555-1212-1234') ③
> > > phonePattern. search('800-555-1212-1234'). groups() ④
Traceback (most recent call last):
File " < stdin> ", line 1, in < module>
AttributeError: 'NoneType' object has no attribute 'groups'

 

• ① Всегда читайте регулярное выражение слева направо. Выражение совпадает с началом строки и потом с (\d{3}). Что такое \d{3}? Итак, \d значит «любая цифра» (от 0 до 9). {3} значит «совпадение с конкретно тремя цифрами»; это вариации на тему {n, m} синтаксиса который вы наблюдали ранее. Если заключить это выражение в круглые скобки, то это значит «совпасть должно точно три цифры и потом запомнить их как группу которую я запрошу позже». Потом выражение должно совпасть с дефисом. Потом совпасть с другой группой из трёх цифр, потм опять дефис. Потом ещё одна группа из четырёх цифр. И в конце совпадение с концом строки.

• ② Чтобы получить доступ к группам которые запомнил обработчик регулярного выражения, используйте метод groups() на объекте который возвращает метод search(). Он должен вернуть кортеж такого количества групп, которое было определено в регулярном выражении. В нашем случае определены три группы, одна с тремя цифрами, другая с тремя цифрами и третья с четырьмя цифрами.

• ③ Это регулярное выражение не окончательный ответ, так как оно не обрабатывает расширение после телефонного номера. Для этого вы должны расширить регулярное выражение.

• ④ Вот почему вы не должны использовать «цепочку» из методов search() и groups() в продакшн коде. Если метод search() не вернёт совпадения, то он вернёт None, это не стандартный объект регулярного выражения. Вызов None. groups() генерирует очевидное исключение: None не имеет метода groups(). (Конечно же это немного менее очевидно, когда вы получаете это исключение из глубин вашего кода. Да, сейчас это говорит мой опыт. )

 

> > > phonePattern = re. compile(r'^(\d{3})-(\d{3})-(\d{4})-(\d+)$') ①
> > > phonePattern. search('800-555-1212-1234'). groups() ②
('800', '555', '1212', '1234')
> > > phonePattern. search('800 555 1212 1234') ③
> > >
> > > phonePattern. search('800-555-1212') ④
> > >

• ① Это регулярное выражение почти идентично предыдущему. Так же как и до этого оно совпадает с началом строки, потом с запомненной группой из трёх цифр, потом дефис, потом запомненная группа из трёх цифр, потом дефис, потом запомненная группа из четырёх цифр. Что же нового? Это совпадение с другим дефисом и запоминаемая группа из одной и более цифры.

• ② Метод groups() теперь возвращает кортеж из четырёх элементов, а регулярное выражение теперь запоминает четыре группы.

• ③ К неудаче это регулярное выражение не является финальным ответом, так как оно подразумевает что различные части номера разделены дефисом. Что случится если они будут разделены пробелами, запятыми или точками?

• ④ Вам необходимо более общее решение для совпадения с различными типами разделителей.

Опаньки! То что делает это регулярное выражение это ещё не совсем то что вы хотите. В действительности это даже шаг назад, так как вы не можете обрабатывать телефонные номера без расширений. Это совершенно не то что вы хотели; если расширение есть, вы бы хотели знать какое оно, но если его нет, вы до сих пор хотите знать различные части телефонного номера.

Следующий пример показывает как регулярное выражение обрабатывает разделители между различными частями телефонного номера.

 

> > > phonePattern = re. compile(r'^(\d{3})\D+(\d{3})\D+(\d{4})\D+(\d+)$') ①
> > > phonePattern. search('800 555 1212 1234'). groups() ②
('800', '555', '1212', '1234')
> > > phonePattern. search('800-555-1212-1234'). groups() ③
('800', '555', '1212', '1234')
> > > phonePattern. search('80055512121234') ④
> > >
> > > phonePattern. search('800-555-1212') ⑤
> > >

 

• ① Держите свою шляпу. У вас совпадает начало строки, потом группа из трёх цифр, потом \D+. Что это за чертовщина? Ок, \D совпадает с любым символом кроме цифр и также «+» означает «1 или более». Итак \D+ означает один или более символом не являющихся цифрами. Это то что вы используете вместо символа дефиса «-» чтобы совпадало с любыми разделителями.

• ② Использование \D+ вместо «-» значит, что теперь регулярное выражение совпадает с телефонным номером разделённым пробелами вместо дефисов.

• ③ Конечно телефонные номера разделенные дефисами тоже срабатывают.

• ④ К неудаче это ещё не окончательный ответ, так как он подразумевает наличие разделителя. Что если номер введён без всяких разделителей?

• ⑤ ОпцаЁ! И до сих пор не решена проблема расширения. Теперь у вас две проблемы, но вы можете справится с ними используя ту же технику.

Следующий пример показывает регулярное выражение для обработки телефонных номеров без разделителей.

 

> > > phonePattern = re. compile(r'^(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') ①
> > > phonePattern. search('80055512121234'). groups() ②
('800', '555', '1212', '1234')
> > > phonePattern. search('800. 555. 1212 x1234'). groups() ③
('800', '555', '1212', '1234')
> > > phonePattern. search('800-555-1212'). groups() ④
('800', '555', '1212', '')
> > > phonePattern. search('(800)5551212 x1234') ⑤
> > >

 

• ① Только одно изменение, замена «+» на «*». Вместо \D+ между частями номера, теперь используется \D*. Помните что «+» означает «1 или более»? Ок, «*» означает «ноль или более». Итак теперь вы можете обработать номер даже если он не содержит разделителей.

• ② Подумать только, это действительно работает. Почему? У вас совпадает начало строки, потом запоминается группа из трёх цифр (800), потом ноль или более нецифровых символов, потом запоминается группа из трёх цифр (555), потом ноль или более нецифровых символов, потом запоминается группа из четырёх цифр (1212), потом ноль или более нецифровых символов, потом запоминается группа из произвольного количества цифр (1234), потом конец строки.

• ③ Различные вариации также работают: точки вместо дефисов, и также пробелы или «x» перед расширением.

• ④ Наконец вы решили давнюю проблему: расширение снова опционально. Если не найдено расширения метод groups() всё ещё возвращает четыре элемента, но четвёртый элемент просто пустая строка.

• ⑤ Я ненавижу быть вестником плохих новостей, но вы ещё не закончили. Что же тут за проблема? Существуют дополнительные символы до «area» кода, но регулярное выражение думает что код города это первое что находится в начале строки. Нет проблем, вы можете использовать ту же технику «ноль или более нецифровых символов» чтобы пропустить начальные символы до кода города.

Следующий пример показывает как работать с символами до телефонного номера.

 

> > > phonePattern = re. compile(r'^\D*(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') ①
> > > phonePattern. search('(800)5551212 ext. 1234'). groups() ②
('800', '555', '1212', '1234')
> > > phonePattern. search('800-555-1212'). groups() ③
('800', '555', '1212', '')
> > > phonePattern. search('work 1-(800) 555. 1212 #1234') ④
> > >

 

• ① Это то же самое что и в предыдущем примере, кроме \D*, ноль или более нецифровых символов, до первой запомненной группы (код города). Заметьте что вы не запоминаете те нецифровые символы до кода города (они не в скобках). Если вы обнаружите их, вы просто пропустите их и запомните код города.
• ② Вы можете успешно обработать телефонный номер, даже со скобками до кода города. (Правая скобка также обрабатывается; как нецифровой символ и совпадает с \D* после первой запоминаемой группы. )
• ③ Простая проверка не поломали ли мы чего-то, что должно было работать. Так как лидирующие символы полностью опциональны, совпадает начало строки, ноль нецифровых символов, потом запоминается группа из трёх цифр (800), потом один нецифровой символ (дефис), потом группа из трёх цифр (555), потом один нецифровой (дефис), потом запоминается группа из четырёх цифр (1212), потом ноль нецифровых символов, потом группа цифр из нуля символов, потом конец строки.
• ④ Вот где регулярное выражение выколупывает мне глаза тупым предметом. Почему этот номер не совпал? Потому что 1 находится до кода города, но вы допускали что все лидирующие символы до кода города не цифры (\D*).

Давайте вернёмся назад на секунду. До сих пор регулярное выражение совпадало с началом строки. Но сейчас вы видите что в начале могут быть непредсказуемые символы которые мы хотели бы проигнорировать. Лучше не пытаться подобрать совпадение для них, а просто пропустить их все, давайте сделаем другое допущение: не пытаться совпадать с началом строки вообще. Этот подход показан в следующем примере.

 

> > > phonePattern = re. compile(r'(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') ①
> > > phonePattern. search('work 1-(800) 555. 1212 #1234'). groups() ②
('800', '555', '1212', '1234')
> > > phonePattern. search('800-555-1212') ③
('800', '555', '1212', '')
> > > phonePattern. search('80055512121234') ④
('800', '555', '1212', '1234')

 

• ① Заметьте отсутствие ^ в регулярном выражении. Вы больше не совпадаете с началом строки. Ничего теперь не подсказывает как следует поступать с введёнными данными вашему регулярному выражению. Обработчик регулярного выражения будет выполнять тяжелую работу чтобы разобраться где же введённая строка начнёт совпадать.
• ② Теперь вы можете успешно обработать телефонный номер который включает лидирующие символы и цифры, плюс разделители любого типа между частями номера.
• ③ Простая проверка. Всё работает.
• ④ И даже это работает тоже.

Видите как быстро регулярное выражение выходит из под контроля? Бросим взгляд на предыдущие итерации. Можете ли вы объяснить разницу между одним и другим?

Пока вы понимаете финальный ответ (а это действительно он; если вы обнаружили ситуацию которую он не обрабатывает, я не желаю об этом знать), напишем подробное регулярное выражение, до тех пор пока вы не забыли почему вы сделали выбор который вы сделали.

 

> > > phonePattern = re. compile(r'''
# don't match beginning of string, number can start anywhere
(\d{3}) # area code is 3 digits (e. g. '800')
\D* # optional separator is any number of non-digits
(\d{3}) # trunk is 3 digits (e. g. '555')
\D* # optional separator
(\d{4}) # rest of number is 4 digits (e. g. '1212')
\D* # optional separator
(\d*) # extension is optional and can be any number of digits
$ # end of string
''', re. VERBOSE)
> > > phonePattern. search('work 1-(800) 555. 1212 #1234'). groups() ①
('800', '555', '1212', '1234')
> > > phonePattern. search('800-555-1212') ②
('800', '555', '1212', '')

 

• ① Кроме того что оно разбито на множество строк, это совершенно такое же регулярное выражение как было в последнем шаге, и не будет сюрпризом что оно обрабатывает такие же входные данные.
• ② Финальная простая проверка. Да, всё ещё работает. Вы сделали это.

⇐ Предыдущая27282930313233343536Следующая ⇒

Поделиться:

Воспользуйтесь поиском по сайту: