ЛАБОРАТОРНАЯ РАБОТА №9

Тема: Регулярные выражения

Цель: Изучение средств языка Python для работы с регулярными выражениями

ОГЛАВЛЕНИЕ

 Оглавление

Введение

Регулярные выражения (англ. regular expressions, сокр. RegExp) – это формальный язык поиска подстрок в тексте и осуществления манипуляций с ними, основанный на использовании метасимволов (англ. wildcard characters). По сути это шаблон (англ. pattern), строка-образец, состоящая из символов и метасимволов и задающая правило поиска.
Регулярные выражения (РВ) изобрел американский математик, один из основателей направления "Компьютерные науки" Стефан Клини (Stephen Kleene), который описал поведение модели нейрона, предложенной в 1940-х гг. Уорреном Маккалоком и Уолтером Питтсом, используя свою систему математических обозначений, названную им "регулярные множества".
Регулярные выражения произвели прорыв в электронной обработке текстов в конце XX века. Многие современные языки программирования имеют встроенную поддержку регулярных выражений. Среди них Perl, Java, PHP, Python, JavaScript и многие др.
Вместе с тем, необходимо заметить, что не все возможные задачи обработки текста могут быть решены с помощью РВ, поскольку язык регулярных выражений относительно прост и ограничен. Кроме того, в отдельных случаях, когда РВ имеют сложную форму, бывает проще решить задачу, применив код на языке Python, который может работать быстрее и иметь более простой вид.

 Оглавление

1 Синтаксис регулярных выражений

1.1 Представление символов

Большинство символов в регулярном выражении являются простыми символами, т.е. такими, которые представляют сами себя, за исключением символов [ ] \ ^ $ . | ? * + ( ) { }, которые являются метасимволами. К метасимволам также относятся некоторые простые символы с предшествующим символом \ (обратный слеш). Метасимволы в РВ имеют следующиее назначение:

• [ ] – набор символов в квадратных скобках именуется символьным классом и позволяет указать интерпретатору регулярных выражений, что на данном месте в строке может стоять один из перечисленных символов. В частности, [abc] задает возможность появления в тексте одной из букв: "a", "b" или "c".
  Если символы идут подряд, можно указать диапазон: например, [abc] эквивалентно [a-c], а символьный класс [А-Яа-я] соответствует всем буквам русского алфавита (за исключением букв "Ё" и "ё").
  Если требуется задать символы, которые не могут стоять на данном месте в строке, то внутри квадратных скобок первым символом указывается символ ^, например, [^A] означает любой символ, кроме "A".
  Если внутри класса стоит метасимвол, он утрачивает свое специальное значие, например, [ab$] – означает, что в строке на этом месте могут стоять символы "a", "b" или "$";
• . – означает любой один символ (кроме символов новой строки);
• \ – если стоит перед метасимволом, экранирует его, т.е. делает обычным символом, например, \. – представляет обычную точку в тексте. И наоборот, символ \, стоящий перед обычным символом, делает его метасимволом, например, \d – обозначает любую цифру.
  Для представления символа "\", который является метасимволом, в регулярном выражении как обычного символа, не имеющено специального значения, необходимо указать "\\". Поскольку РВ в языке Python являются строками, то, с учетом этого, символ "\" будет представлен в регулярном выражении как "\\\\". Чтобы этого избежать, можно воспользоваться префиксом "r" (см. подраздел 2.1 лаб. раб. №2), который создает строку, в которой все символы представляют сами себя. Таким образом '\n' является односимвольной строкой, представляющей символ новой строки, а r'\n' – строкой, состоящей из двух символов ("\" и "n"). Обычно используюется этот способ задания регулярных выражений;
• [\b] – символ backspace, не путать с \b, обозначающим границу слова ( см. подраздел 1.2);
• \cx – комбинация клавиш CTRL-x, где x – буква от A до Z, например, \cM означает CTRL-M;
• \d – любая цифра от 0 до 9 (эквивалентно классу [0-9]);
• \D – любой нецифровой символ;
• \f – символ новой страницы;
• \n – символ новой строки;
• \r – символ возврата каретки;
• \s – любой разделительный символ (эквивалентно классу [ \t\n\r\f\v]);
• \S – все, за исключением перечисленного в /s (эквивалентно классу [^ \t\n\r\f\v]). Поэтому для указания в регулярном выражении того, что на этом месте может стоять любой символ текста, можно использовать символьный класс [\s\S];
• \t – символ табуляции;
• \v – символ вертикальной табуляции;
• \w – латинская буква, цифра или знак подчеркивания (эквивалентно классу [A-Za-z0-9_]);
• \W – все, за исключением перечисленного в \w;
• | – разделяет допустимые варианты. Например, gray|grey соответствует gray или grey. Перебор вариантов выполняется слева направо. Если требуется указать перечень вариантов внутри более сложного РВ, то его нужно заключить в группу. Например, вариант gr[ae]y предпочтителен, так как сравнение с символьным классом выполняется проще, чем обработка группы с проверкой на все ее возможные модификаторы;
• \0 – None;
• \k – обратная ссылка на запомненную k-й парой скобок подстроку.

 Оглавление

1.2 Позиция внутри строки

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

• ^ – начало строки (позиция перед первым символом строки), т.е. проверяемый текст должен обязательно начинаться с начала строки;
• $ – конец строки (позиция после последнего символа строки), т.е. проверяемый текст должен обязательно заканчиваться в конце строки;
• \b – граница слова;
• \B – не граница слова;
• \A – начало строки, но в отличие от символа ^ не изменяет свое значение при наличии флага M;
• \Z – конец строки, но в отличие от символа $ не изменяет свое значение при наличии флага M.

 Оглавление

1.3 Квалификаторы повторения

Квалификатор (англ. qualifier) повторения после символа, символьного класса или группы (см. подраздел 2.4 ) определяет, сколько раз предшествующее выражение может встречаться в строке:

• {n} – ровно n;
• {m,n} – от m до n включительно;
• {m,} – не менее m;
• {,n} – не более n;
• * (звезда Клини) – ноль или более, т.е. может и не встречаться;
• + – один или более;
• ? – ноль или один.

Если символы { } не образуют квалификатор, их специальное значение игнорируется.

 Оглавление

2 Функции, методы и константы регулярных выражений

2.1 Модуль re

Для работы с регулярными выражениями на языке Python необходимо подключить модуль re, который содержит описания функций, констант и исключения.
Регулярные выражения на языке Python могут быть заданы в двух формах:

• в виде шаблонов регулярных выражений, представленных строками (класс str);
• в виде объектов регулярных выражений, полученных из шаблонов РВ путем их компиляции (класс RegexpObject).

Компиляция осуществляется с помощью функции compile(pattern[,flags]) модуля re, которая компилирует шаблон РВ pattern, заданный в виде строки, и возвращает результат в виде объекта регулярного выражеиния (экземпляра класса RegexpObject). Необязательный параметр flags позволяет модифицировать поведение регулярного выражения (см. подраздел 2.1.1 ).
Использование объектов РВ, которые имеют свои методы поиска (см. подраздел 2.2 ), вместо шаблонов РВ позволяет ускорить работу с регулярными выражениями. Кроме того, последние используемые объекты РВ кэшируются и не требуют повторной компиляции. Методы объектов РВ имеют дополнительные возможности по сравнению с функциями модуля re. Поэтому большинство нетривиальных решений использует именно объекты регулярных выражений.

 Оглавление

2.1.1 Константы модуля re

Модуль re содержит константы, которые задают значения следующих флагов регулярных выражений, используемых в функциях модуля re (см. подраздел 2.1.2 ) (в скобках показана сокращенная форма флага):

• ASCII (A) – позволяет осуществлять сравнение при использовании \w, \W, \b, \B, \d, \D, \s и \S только с символами, заданными в ASCII-коде (вместо использования кода Unicode). Имеет смысл для шаблонов, заданных в коде Unicode;
• IGNORECASE (I) – позволяет игнорировать регистр символов;
• LOCALE (L) – позволяет учитывать при использовании \w, \W, \b, \B,\d, \D, \s и \S локальную кодировку (например, для некоторызх французких букв);
• MULTILINE (M) – позволяет символу '^' в строке, содержащей несколько символов новой строки, указывать начало поиска не только с начала строки, но и с начала каждой части строки, следующей за символом ('\n'), а символу '$' указывать окончание поиска не только в конце строки, но и перед каждым символом ('\n');
• DOTALL (S) – позволяет специальному символу '.' представлять любой символ, включая символ новой строки (без этого флага символ '.' представлял любой символ, не включая символа новой строки);
• VERBOSE (X) – позволяет задать регулярное выражение в виде, более ясном для понимания. При этом в РВ разрешается ставить разделительные символы (кроме тех, что указаны в символьных классах или тех, которые следуют за символом обратного слэша). Кроме того, в регулярном выражении можно указывать комментарии (используя символ '#'). Например, следующие два регулярных выражений эквивалентны (первое использует флаг X, второе – нет):
  
  >>> import re
  >>> a = re.compile( r"""\d + # the integral part
  \. # the decimal point
  \d * # some fractional digits""" , re.X);
  >>> b = re.compile( r"\d+\.\d*" );
  

 Оглавление

2.1.2 Функции модуля re

Помимо функции compile() (см. подраздел 2.1 ) модуль re содержит следующие функции:

• search(pattern, string[, flags]) – просматривает строку string, сравнивая ее подстроки с шаблоном регулярного выражения pattern. При обнаружении такой подстроки – возвращает объект, экземпляр класса MatchObject. В противном случае – возвращает значение None;
• match(pattern, string[, flags]) – если нуль или больше символов начала строки string совпадают с шаблоном РВ pattern – возвращает объект, экземпляр класса MatchObject. В противном случае – возвращает значение None;
• split(pattern, string[, maxsplit=0, flags=0]) – разделяет строку string на подстроки и возвращает список подстрок. Разделителем служит шаблон РВ pattern. Необязательный параметр maxsplit указывает индекс последнего элемента списка. При этом оставшаяся часть строки добавляется в этот последний элемент:
  
  >>> re.split( '-','1-2-3-4-5-6' )
  ['1', '2', '3', '4', '5', '6']
  >>> re.split( '-','1-2-3-4-5-6' ,3)
  ['1', '2', '3', '4-5-6'].
  
  Если шаблон РВ взять в скобки, то содержимое шаблона будет включено в результирующий список подстрок:
  
  >>> re.split( '(-)','1-2-3-4-5-6' )
  ['1', '-', '2', '-', '3', '-', '4', '-', '5', '-', '6'] ;
  
  
• findall(pattern, string[, flags]) – возвращает список подстрок, найденных с помощью шаблона РВ pattern в строке string. При этом строка сканируется слева направо и совпадения включаются в список в порядке их обнаружения. Если одна или более групп указана в шаблоне, то возращается список групп. Это будет список кортежей, если шаблон имеет более одной группы:
  
  >>> re.findall( '(-)','r'\d','2 cats and 3 dogs' )
  ['2', '3'] ;
  
  
• finditer(pattern, string[, flags]) – возвращает найденные с помощью шаблона pattern подстроки строки string в виде итератора;
• sub(pattern, repl, string[, count, flags]) – возвращает строку, полученную путем замены самой левой подстроки, найденной шаблоном РВ pattern, в строке string на значение repl. Если подстрока не найдена – возращается исходная строка. Параметр repl может быть строкой или функцией.
  Если это строка, то любой обратный слэш в esc-последовательности будет обрабатываться. Это значит, что "\n" преобразуется в символ новой строки. Неизвестная esc-последовательность, такая как "\j", остается без изменения. Обратные ссылки, такие как \6, заменяются подстрокой, найденной группой 6 регулярного выражения:
  
  >>> s= 'It\'s a cat\n'
  >>> re.sub( 'cat' , 'small cat' ,s)
  "It's a small cat\n".
  
  Если это функция, она вызывается по каждому непересекающемуся совпадению с шаблоном. Функция получает единственный аргумент в виде объекта типа match и возвращает значение в виде измененной строки;
• subn(pattern, repl, string[, count, flags]) – выполняет те же операции, что и функция sub(), но возвращает кортеж, элементами которого явзяются: измененная строка и число подстановок;
• escape(string) – возвращает строку string с добавлением обратых слэшей ко всем символам, не являющимися цифрами или буквами. Это бывает полезно сделать в случае поиска в произвольной строке, которая может содержать метасимволы РВ:
  
  >>> re.escape( '^Hello, world!#' )
  '\\^Hello\\,\\ world\\!\\#';
  
  
• purge() – очищает кэш регулярных выражений;

 Оглавление

2.2 Методы объектов класса RegexpObject

Объекты регулярных выражений (экземпляры класса RegexpObject) возвращает функция compile() модуля re в результате компиляции регулярных выражений, заданных в виде шаблона-строки (см. подраздел 2.1 ):

>>> import re
>>> p=re.compile( 'ab*' ).

Объекты класса RegexpObject имеют следующие методы:

• search(string[, pos[, endpos]]) – осуществляет поиск вдоль строки string, определяя местоположение подстроки, совпадающей с РВ, и в случае совпадения возвращает соответствующий экземпляр класса MatchObject. Если такое место в строке не найдено – возвращает значение None. Отметим, что это не одно и то же, что найти в некотором месте строки сравнение нулевой длины.
  Необязательный параметр pos задает позицию в строке, где начинается поиск. Это не полностью эквивалентно использованию метоасимвола "^", который указывает и на начало строки, и на начало каждой части строки, начинающейся символом новой строки.
  Необязательный параметр endpos задает границу поиска в строке (могут сравниваться только символы с индексами не больше endpos - 1). Если endpos меньше pos – сравнение не будет осуществляться:
  
  >>> p.search( 'the absolute' )
  <_sre.SRE_Match object; span=(4, 6), match='ab'>;
  
  
• match(string[, pos[, endpos]]) – если нуль или более символов строки string совпадают с РВ, возвращает соответствующий экземпляр класса MatchObject. В противном случае возвращает значение None. Необязательные параметры pos и endpos имеют те же назначение, что и для метода search():
  
  >>> p.match( 'abba' )
  <_sre.SRE_Match object; span=(0, 3), match='abb'>.
  
  Если подстрока не найдена – возвращается значение None:
  
  >>> print (p.match( ''Abba'' ))
  None;
  
  Если подстрока не начинается с начала строки, она не находится:
  
  >>> if not p.match( ' abba'' ): print ( 'Подстрока не найдена' )
  Подстрока не найдена,
  
  В этом случае необходимо использовать метод search();
• split(string[, maxsplit=0]) – идентичен функции split() модуля re, но использует скомпилированное РВ в виде объекта класса RegexpObject;
• findall(string[, pos[, endpos]]) – идентичен функции findall() модуля re, но использует скомпилированное РВ в виде объекта класса RegexpObject. Также может принимать необязательные параметры pos и endpos, для задания диапазона поиска подобно методу match() :
  
  >>> p.findall( ''"abba\'s" music - abcolute'' )
  ['abb', 'a', 'ab'];
  
  
• finditer(string[, pos[, endpos]]) – идентичен функции finditer() модуля re, но использует скомпилированное РВ в виде объекта класса RegexpObject. Также может принимать необязательные параметры pos и endpos, для задания диапазона поиска подобно методу match();
• sub(repl, string[, count=0]) – идентичен функции sub() модуля re, но использует скомпилированное РВ в виде объекта класса RegexpObject;
• subn(repl, string[, count=0]) – идентичен функции subn() модуля re, но использует скомпилированное РВ в виде объекта класса RegexpObject.

 Оглавление

2.3 Методы объектов класса MatchObject

Функции search() и match() модуля re, а также методы search() и match() объектов класса RegexpObject при успешном поиске возвращают значения в виде объектов класса MatchObject:

>>> r=p.match( 'abba' )
>>> r
<_sre.SRE_Match object; span=(0, 3), match='abb'>.

В противном случае возвращаеют значение None:

>>> print (p.match( 'cat' )
None .

Объекты класса MatchObject имеют следующие методы:

• group([group1, ...]) – возвращает одну или больше найденных групп (см. подраздел 2.4). Если аргументы не заданы, принимается значение по умолчанию – нуль, в этом случае возращается вся найденная подстрока:
  
  >>> r.group()
  'abb';
  
  Если указан единственный аргумент, результатом будет единственная строка. Если указано несколько аргументов, результатом будет кортеж, каждый элемент которого задает одну строку:
  
  >>> m=re.match( r"(\w+)\s(\w+)" , "Isaac Newton, physicist" )
  >>> m.group()
  'Isaac Newton';
  >>> m.group(1)
  'Isaac';
  >>> m.group(2)
  'Newton';
  >>> m.group(1, 2)
  ('Isaac', 'Newton');
  
  
• groups([defaults]) – возвращает кортеж, содержащий все сравненные группы. Значение по умолчанию (None) указывается для тех групп, для которых не произошло сравнение:
  
  >>> m=re.match( r"(\d+)\.(\d+)" , "25.341" )
  >>> m.groups()
  ('25', '341');
  
  
• groupdict([default]) – возвращает словарь, содержащий все именованные группы (см. подраздел 2.4), ключами которого являются имена этих групп. Аргумент по умоляанию (None) используется для тех групп, которые не принимали участие в сравнении.
• start([group])
  end([group]) – возвращают начальный и конечный индексы найденной подстроки:
  
  >>> r.start()
  0;
  >>> r.end()
  3;
  
  
• span([group]) – возвращает кортеж, содержащий позицию (start,end) подстроки:
  
  >>> r.span()
  (0,3).
  
  

Метод span() можно также использовать для просмотра позиций найленных подстрок итератора, полученного методом p.finditer():

>>> ite=p.finditer( '"abba\'s" music - abcolute ' )
>>> ite
<callable_iterator object at 0x02308EB0>
>>> for m in ite: print (m.span())
(1, 4)
(4, 5)
(17, 19)

 Оглавление

2.4 Использование скобок в регулярных выражениях

Для обозначения группы символов регулярного выражения используются круглые скобки, которые, являясь метасимволами, определяют операции, их область действия и приоритет над указанными в группе символами.
В настоящее время скобкам регулярных выражений уделяется особое внимание. Например, разработчики последних версий языка PERL дальнейшее развитие РВ видят не в создании новых метасимволов или разработке новых методов, а в использовании скобок для задания специальных выражений, расширяющих функциональные возможности регулярных выражений. По этому пути пошли и разработчики яыка Python – для указания особенностей регурярных выражений языка Python в скобках помещается буква "P" (см. ниже).
Шаблон внутри группы обрабатывается как единое целое, может быть квалифицирован и выполняет сделующие функции:

• (. . .) – находит и запоминает подстроку согласно РВ ". . .". Это "скобки с запоминанием". Они, во-первых, выполняют типичную для них роль объединения отдельных частей в единое целое (как в математике), например (abc){3} – означает троекратное повторение последовательности букв abc. Во-вторых, они запоминают в памяти результаты поиска, к которым в последствии можно обратиться. Для задания в строке символов '(' и ')', представляющих самих себя, можно использовать обратные слэши: \( и \) или символьные классы [(] и [)]. Например, скобки могут быть использованы при преобразовании даты из формата "ММ/ДД/ГГГГ" в формат "ДД.ММ.ГГГГ". При этом в регулярном выражении создаются три пары скобок, содержащие РВ для поиска трех подстрок: первая – цифр номера месяца, вторая – цифр дня месяца, третья – цифр года:
  
  >>> date= '03/11/2016'
  >>> m=re.match( r'(\d{1,2})/(\d{1,2})/(\d{4})$' ,date)
  >>> if m: print (m.group(2), '.' , m.group(1), '.' , m.group(3), sep= '' )
  else : print ( 'Дата задана неверно' )
  11.03.2016 ;
  
  
• (?: . . . ) – это "скобки без запоминания". Они выполняют только функцию объединения. Поэтому, если результат группы в дальнейшем не понадобится, лучше использовать этот вид группирования. Это повышает скорость выполнения;
• (?aiLmsux) – один или более символов из набора 'a', 'i', 'L', 'm', 's', 'u', 'x' указывает на наличие в РВ соответствующего флага (см. подраздел 2.1.1): re.A (сравнение только с ASCII-символами), re.I (игнорируется регистр), re.L (зависимость от внутренней кодировки), re.M (строка содержит несколько символов \n), re.S (точка сравнивает все) и re.X (удобный вид). Поиск слов без использования флага IGNORECASE:
  
  >>> p=re.compile( r'[A-Z]\w+' )
  >>> p.findall( 'The cat and the dog' )
  ['The']
  
  и с использованием флага IGNORECASE:
  
  >>> p=re.compile( r'(?i)[A-Z]\w+' )
  >>> p.findall( 'The cat and the dog' )
  ['The', 'cat', 'and', 'the', 'dog'];
  
  
• (?P<name>. . .) – задает имя группы name. В дальнейшем по этому имени можно обращаться к группе. Имена групп в пределах регулярного выражения должны различаться:
  
  >>> m=re.match( r'(?P<first_name>\w+)\s(?P<second_name>\w+)' , 'Isaac Newton' )
  >>> m.group( 'first_name' )
  'Isaac'
  >>> m.group( 'second_name' )
  'Newton'
  >>> m.group()
  'Isaac Newton';
  
  
• (?= . . .) – находит сравнение, если только дальше следует ". . . ". Например, метод sub() заменяет в строке s строчные буквы i на заглавные I только в названиях фирмы:
  
  >>> s= 'Фирма intel выпускает процессоры серии intel Core: i7, i5 и i3'
  >>> p=re.compile( 'i(?=ntel)' )
  >>> p.sub( 'I' ,s)
  'Фирма Intel выпускает процессоры серии Intel Core: i7, i5 и i3';
  
  
• (?! . . . ) – находит подстроку, если только дальше не следует ". . . ". Например, РВ не находит в строке первое слово "a", поскольку дальше следует пробел :
  
  >>> p=re.compile( r'a\w+(?!\s)' )
  >>> p.search( 'a atom' )
  'atom';
  
  
• (?<= . . . ) – находит подстроку, если только ей предшествоовало ". . . ". Например, РВ находит в строке только те числа, которым предшествовал символ "№":
  
  >>> p=re.compile( r'(?<=№)\d+' )
  >>> p.findall( '1, №2, №33, 4, 55' )
  ['2', '33'];
  
  
• (?<! . . . ) – находит подстроку, если только ей не предшествовало ". . . ";

Одно из применений группирования – повторное использование ранее найденных групп символов (подстрок, блоков, отмеченных подвыражений). При обработке выражения подстроки, найденные по шаблону внутри группы, сохраняются в памяти и получают номер начиная с единицы. Каждой подстроке соответствует пара скобок в регулярном выражении. Python поддерживается до 99 нумерованных подстрок с номерами от 1 до 99. В регулярном выражении можно ссылаться на раннее найденные группы по их номерам, используя обратный слэш – \1 - \99. Например, найдем в строке повторяющиеся слова:

>>> p=re.compile( r'(\b\w+)\s+\1' )
>>> p.search( 'The cat and the the dog' ).group()
'the the'.

3 Использование регулярных выражений

Использование регулярных выражений для проверки данных пользователя показано в клиент-серверном приложении, клиентская часть которого реализована в виде примера №1, содержащего HTML-форму, которая имеет текстовое поле для ввода фамилии и инициалов пользователя ("user_name") и две кнопки: "Сброс" и "Передать данные":

 Оглавление

Пример №1

<!DOCTYPE html>
<html>
<head>
<title>Передача данных серверу для проверки</title>
<link rel="stylesheet" href="file:///D:/!PYTHON/lab.css">
</head>
<body>
<h1>Передача данных серверу для проверки</h1>
<form method="get" action="http://zykov/PYTHON/get_data_form.py">
Введите фамилию и инициалы:
<input type="text" class="form" name="user_name"><br><br>
<input type="reset" value="Сброс" class="kn">&nbsp;&nbsp;
<input type="submit" value="Передать данные" class="kn">
</form>
</body>
</html>

После ввода пользователем своей фамилии и инициалов и нажатия кнопки "Передать данные" браузер отправляет введенные данные серверному приложению get_data_form.py:

#!c: . . . /Python35-32/python.exe
print ( "Content-Type: text/html\n" )
import cgi, cgitb, my_cgi, re
cgitb.enable()
user_name=cgi.parse()[ "user_name" ][0]
print (my_cgi.H, "Проверка данных пользоваетеля с помощью регулярных выражений" )
p=re.compile( r'^([А-Я][а-я]+)\s[А-Я]\.[А-Я]\.$' )
m=p.match(user_name)
if m:
print (my_cgi.H2, "Тов. " , m.group(1), "!" , sep= "" )
print (my_cgi.D, "Данные введены правильно." )
else : print (my_cgi.D, "Данные введены неправильно." ),

которое выполняет следующие действия:

• в первых строках указывает путь к интерпретатору языка Python 3.3 и формирует http-заголовок;
• подключает модули языка Python (cgi, cgitb и re), а также пользовательский модуль my_cgi, который содержит форматы для представления данных, отсылаемых клиенту;
• инициализирует обработчик ошибок модуля cgitb с заданием значений по умолчанию;
• с помощью метода cgi.parse() получает фамилию и инициалы пользователя (переменная user_name);
• сообщает пользователю о начале проверки его данных;
• создает шаблон соответствующего регулярного выражения и компилирует его с помощью функции compile(), получая экземпляр класса RegexpObject (переменная p);
• осуществляет сравнение с помощью метода match() введенных данных с объектом регулярного выражения, получая экземпляр класса MatchObject (переменная m);
• если значение m не равно None, то пользователю сообщается:

  Тов. Петров!

  Данные введены правильно.

  В противном случае сообщается:

  Данные введены неправильно.
  
  

 Оглавление

Индивидуальные задания

Разработать приложение на базе технологии "клиент-сервер".
В задачи клиентской части входит: разработать HTML-документ, содержащий форму, обязательными элементами которой являются:

• три текстовых поля для ввода данных пользователя:
  • поле для ввода факультета и группы (name="data1");
  • поле для ввода имени студента (name="data2");
  • поле для ввода номера зачетной книжки (ЗК) и номера телефона (name="data3");
• текстовое поле для ввода литерала;
• кнопка для передачи данных на сервер.

В задачи серверной части входит:

• принять данные из формы;
• сформировать три шаблона регулярных выражений для проверки данных "data1" "data2" и "data3" согласно колонкам "Данные1"/"Шаблон", "Данные2"/"Шаблон" и "Данные3"/"Шаблон" табл. 1. Вводимые данные имеют постоянную и изменяемую части (последняя указана в фигурных скобках). Например, формат "Группа:{}" означает, что должно быть введено слово "Группа: ", а затем название группы (фигурные скобки не вводятся);
• сформировать шаблон РВ для проверки правильности задания литерала согласно колонке "Литерал":
  • 1 – литерала списка, содержащего следующие элементы:
    1-й элемент – строка;
    2-й элемент – число с плавающей точкой;
    3-й элемент – логического типа;
    
  • 2 – литерала кортежа; содержащего следующие элементы:
    1-й элемент – целое число;
    2-й элемент – список из трех строк;
    
  • 3 – литерала диапазона;
  • 4 – литерала множества, содержащего следующие элементы:
    1-й элемент – кортеж из черырех целых чисел;
    2-й элемент – строка;
    
  • 5 – литерала словаря, содержащего два элемента:
    ключ 1-го элемента – строка, значение – строка;
    ключ 2-го элемента – целое число, значение – число с плавающей точкой;
• использовать для проверки данных функции или методы согласно "Данные1"/"Метод", "Данные2"/"Метод" и "Данные3"/"Метод" табл. 1 (для проверки колонки "Литерал" использовать метод, который не использовался при проверках данных "data1" "data2" и "data3"):
  • 1 – функцию match() модуля re;
  • 2 – функцию search() модуля re;
  • 3 – метод match() класса RegexpObject;
  • 4 – метод search() класса RegexpObject;
• по результатам всех проверок передать пользоваетелю соответствующее сообщение.

 Оглавление