Как получить конкретное сообщение об ошибке для проверки данных с помощью Regex с Python 3

Question

Как получить конкретный вывод, как в следующих примерах:

пример 1 - если пользователь вводит Альберта, ООН .Я хочу видеть результат печати как Извините, ООН является недопустимым сокращением провинции. Мне бы очень хотелось, если бы программа могла отображать точную ошибку по отношению к пользователю.вход.Вместо ошибки, говорящей Извините, это ошибка , без какого-либо специального сообщения, чтобы сообщить пользователю, где его ошибка.

Я был бы очень признателен, если бы смог получить некоторые результаты, потому что я проводил мозговой штурм о том, как заставить его работать

# Import
import re

# Program interface
print("====== POSTAL CODE CHECKER PROGRAM ====== ")
print("""
Select from below city/Province and enter it
--------------------------------------------
Alberta, AB,
British Columbia, BC
Manitoba, MB
New Brunswick, NB
Newfoundland, NL
Northwest Territories, NT
Nova Scotia, NS
Nunavut, NU
Ontario, ON
Prince Edward Island, PE
Quebec, QC
Saskatchewan, SK
Yukon, YT
""")

# User input 1
province_input = input("Please enter the city/province: ")

pattern = re.compile(r'[ABMNOPQSYabcdefhiklmnorstuvw]| [CBTSE]| [Idasln], [ABMNOPQSY]+[BCLTSUNEK]')

if pattern.match(province_input):
    print("You have successfully inputted {} the right province.".format(province_input))
elif not pattern.match(province_input):
    print("I'm sorry, {} is an invalid province abbreviation".format(province_input))
else:
    print("I'm sorry, your city or province is incorrectly formatted.")

Answer 1

Я попытался обобщить ваш вопрос, поэтому он проверит, является ли первая часть ввода допустимым городом, а вторая - действительным сокращением штата, когда «действительный» означает, что каждый из них появляется в соответствующем списке допустимых входных данных.

Ядром кода является регулярное выражение ([A-Z][A-Za-z ]+), ([A-Z]{2}), которое соответствует двум группам: первая группа содержит город - а после запятой и пробел - вторая группа содержит сокращение штата (которое должен состоять из двух заглавных букв).

Обратите внимание, что есть 5 возможных выходов, в зависимости от действительности каждой части.

import re

cities = ["Alberta", "British Columbia", "Manitoba"]
states = ["AB", "BC", "MB"]

province_input = input("Please enter the city/province: ")
regexp = r"([A-Z][A-Za-z ]+), ([A-Z]{2})"

if re.compile(regexp).match(province_input):
    m = re.search(regexp, province_input)
    city_input = m.group(1)
    state_input = m.group(2)
    if city_input not in cities and state_input not in states:
        print("Both '%s' and '%s' are valid" % (city_input, state_input))
    elif city_input in cities:
        if state_input in states:
            print("Your input '%s, %s' was valid" % (city_input, state_input))
        else:
            print("'%s' is an invalid province abbreviation" % state_input)
    else:
        print("The city '%s' is invalid" % city_input)
else:
    print("Wrong input format")

Я пытался сделать код как можно более понятным, но, пожалуйста, дайте мне знать, если что-то неясно.

Answer 2

Не программист на Python, но я думаю, что если вы import regex
новая замена регулярных выражений lib, она даст вам доступ к
Филиал Сброс конструкция.

Используя это, тривиально разделить город и провинцию на 3 группы.

Итак, просто сопоставьте это регулярное выражение
[ \t]*(?|(Alberta)(?:[ \t]*,[ \t]*(?:(AB)|(\w+)))?|(British[ \t]+Columbia)(?:[ \t]*,[ \t]*(?:(BC)|(\w+)))?|(Manitoba)(?:[ \t]*,[ \t]*(?:(MB)|(\w+)))?|(New[ \t]+Brunswick)(?:[ \t]*,[ \t]*(?:(NB)|(\w+)))?|(Newfoundland)(?:[ \t]*,[ \t]*(?:(NL)|(\w+)))?|(Northwest[ \t]+Territories)(?:[ \t]*,[ \t]*(?:(NT)|(\w+)))?|(Nova[ \t]+Scotia)(?:[ \t]*,[ \t]*(?:(NS)|(\w+)))?|(Nunavut)(?:[ \t]*,[ \t]*(?:(NU)|(\w+)))?|(Ontario)(?:[ \t]*,[ \t]*(?:(ON)|(\w+)))?|(Prince[ \t]+Edward[ \t]+Island)(?:[ \t]*,[ \t]*(?:(PE)|(\w+)))?|(Quebec)(?:[ \t]*,[ \t]*(?:(QC)|(\w+)))?|(Saskatchewan)(?:[ \t]*,[ \t]*(?:(SK)|(\w+)))?|(Yukon)(?:[ \t]*,[ \t]*(?:(YT)|(\w+)))?|()(\w+)())

Проверьте группы в следующем порядке:

если НЕТ совпадение: Please enter 'City, Province' from the list
иначе, если длина $ 1 равна 0: '$2' is not a valid City
иначе, если длина $ 3> 0: '$3' is not a valid Province
иначе, если длина $ 2 равна 0: Please enter a Province
остальное: Thank you, your entry is valid '$1, $2'

Демо: https://regex101.com/r/MrlqEN/1

Расширен

 [ \t]*     
 (?|
      ( Alberta )                   # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( AB )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( British [ \t]+ Columbia )   # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( BC )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Manitoba )                  # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( MB )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( New [ \t]+ Brunswick )      # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( NB )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Newfoundland )              # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( NL )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Northwest [ \t]+ Territories )  # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( NT )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Nova [ \t]+ Scotia )        # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( NS )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Nunavut )                   # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( NU )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Ontario )                   # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( ON )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Prince [ \t]+ Edward [ \t]+ Island )  # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( PE )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Quebec )                    # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( QC )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Saskatchewan )              # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( SK )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( Yukon )                     # (1)
      (?:
           [ \t]* , [ \t]* 
           (?:
                ( YT )                        # (2)
             |  ( \w+ )                       # (3)
           )
      )?
   |  ( )                           # (1)
      ( \w+ )                       # (2)
      ( )                           # (3)
 )