Содержание

Регулярные выражения в Python | Pythonist .ru

Перевод статьи «Python Regular Expression».

Сегодня мы хотим поговорить о регулярных выражениях в Python. Пожалуй, стоит начать с определения. Регулярные выражения, иногда называемые re, regex или regexp, представляют собой последовательности символов, составляющие шаблоны, соответствия которым ищутся в строке или тексте. Для работы с regexp в Python есть встроенный модуль re.

Обычное использование регулярного выражения:

  • Поиск подстроки в строке (search and find)
  • Поиск всех подходящих строк (findall)
  • Разделение строки на подстроки (split)
  • Замена части строки (sub)

Основы

Регулярное выражение – это комбинация символов и метасимволов. Из метасимволов доступны следующие:

  • \ используется для игнорирования специального значения символа
  • [] указывает на класс символов. соответствует началу текста
  • $ обозначает конец текста
  • . соответствует любому символу, кроме символа новой строки
  • ? обозначает одно или ноль вхождений
  • | означает ИЛИ (совпадение с любым из символов, разделенных им)
  • * любое количество вхождений (включая 0 вхождений)
  • + одно и более вхождений
  • {} указывает на несколько совпадений предыдущего RE.
  • () отделяет группу в регулярном выражении

Обратная косая черта (backslash) \ используется в сочетании с другими символами и тогда приобретает особые значения. Если же необходимо использовать backslash просто как символ, без учета специального значения, его нужно «экранировать» еще одной обратной косой чертой – \\. Что касается специальных значений:

  • \d соответствует любой десятичной цифре, это то же самое, что и [0-9]
  • \D соответствует любому нечисловому символу
  • \s соответствует любому пробельному символу
  • \S соответствует любому не пробельному символу
  • \w соответствует любому буквенно-числовому символу; это то же самое, что и [a-zA-Z0-9_].
  • \W соответствует любому не буквенно-числовому символу.

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

re.search()

Этот метод возвращает совпадающую часть строки и останавливается сразу же, как находит первое совпадение. Таким образом, его можно использовать для проверки выражения, а не для извлечения данных.

Синтаксис: re.search(шаблон, строка)

Возвращаемое значение может быть либо подстрокой, соответствующей шаблону, либо None, если такой подстроки не окажется.

Давайте разберем пример: поищем в строке месяц и число.

import re  
regexp = r"([a-zA-Z]+) (\d+)"
match = re.search(regexp, "My son birthday is on July 20")
if match != None:
    print("Match at index %s, %s" % (match. start(), match.end()))   #This provides index of matched string
    print("Full match: %s" % (match.group(0)))
    print("Month: %s" % (match.group(1)))
    print("Day: %s" % (match.group(2)))
else:
    print("The given regex pattern does not match")

re.match()

Этот метод ищет и возвращает первое совпадение. Но надо учесть, что он проверяет соответствие только в начале строки.

Синтаксис: re.match(шаблон, строка)

Возвращаемое значение, как и в search(), может быть либо подстрокой, соответствующей шаблону, либо None, если желаемый результат не найден.

Теперь давайте посмотрим на пример. Проверим, совпадает ли строка с шаблоном.

 
import re
regexp = r"([a-zA-Z]+) (\d+)"
match = re.match(regexp, "July 20")
if match == None:
    print("Not a valid date")
else:
    print("Given string: %s" % (match. group()))
    print("Month: %s" % (match.group(1)))
    print("Day: %s" % (match.group(2)))

Рассмотрим другой пример. Здесь «July 20» находится не в начале строки, поэтому результатом кода будет «Not a valid date»

 
import re
regexp = r"([a-zA-Z]+) (\d+)"
match = re.match(regexp, "My son birthday is on July 20")
if match == None:
    print("Not a valid date")
else:
    print("Given string: %s" % (match.group()))
    print("Month: %s" % (match.group(1)))
    print("Day: %s" % (match.group(2)))

re.findall()

Этот метод возвращает все совпадения с шаблоном, которые встречаются в строке. При этом строка проверяется от начала до конца. Совпадения возвращаются в том порядке, в котором они идут в исходной строке.

Синтаксис: re.findall(шаблон, строка)

Возвращаемое значение может быть либо списком строк, совпавших с шаблоном, либо пустым списком, если совпадений не нашлось.

Рассмотрим пример. Используем регулярное выражение для поиска чисел в исходной строке.

import re
string  = "Bangalore pincode is 560066 and gulbarga pincode is 585101"
regexp = '\d+'            
match = re.findall(regexp, string)
print(match)

Или другой пример. Теперь нам нужно найти в заданном тексте номер мобильного телефона. То есть, в данном случае, нам нужно десятизначное число.

import re
string = "Bangalore office number 1234567891, My number is 8884278690, emergency contact 3456789123 invalid number 898883456"
regexp = '\d{10}'  # Регулярное выражение, соответствующее числу из ровно 10 цифр            
match = re. findall(regexp, string)
print(match)

re.compile()

С помощью этого метода регулярные выражения компилируются в объекты шаблона и могут использоваться в других методах. Рассмотрим это на примере поиска совпадений с шаблоном.

import re
e = re.compile('[a-e]')
print(e.findall("I born at 11 A.M. on 20th July 1989"))
e = re.compile('\d')  # \d - эквивалент [0-9].
print(e.findall("I born at 11 A.M. on 20th July 1989"))
p = re.compile('\d+')  # группа из одной или более цифр
print(p.findall("I born at 11 A.M. on 20th July 1989"))
# Результат:
# ['b', 'a']
# ['1', '1', '2', '0', '1', '9', '8', '9']
# ['11', '20', '1989']

re.split()

Данный метод разделяет строку по заданному шаблону. Если шаблон найден, оставшиеся символы из строки возвращаются в виде результирующего списка. Более того, мы можем указать максимальное количество разделений для нашей строки.

Синтаксис: re.split(шаблон, строка, maxsplit = 0)

Возвращаемое значение может быть либо списком строк, на которые была разделена исходная строка, либо пустым списком, если совпадений с шаблоном не нашлось.

Рассмотрим, как работает данный метод, на примере.

 
import re
# '\W+' совпадает с символами или группой символов, не являющихся буквами или цифрами
# разделение по запятой ',' или пробелу ' '
print(re.split('\W+', 'Good, better , Best'))
print(re.split('\W+', "Book's books Books"))
# Здесь ':', ' ' ,',' - не буквенно-цифровые символы, по которым происходит разделение
print(re.split('\W+', 'Born On 20th July 1989, at 11:00 AM'))
# '\d+' означает цифры или группы цифр
# Разделение происходит по '20', '1989', '11', '00'
print(re.
 
 split('\d+', 'Born On 20th July 1989, at 11:00 AM'))
# Указано максимальное количество разделений - 1
print(re.split('\d+', 'Born On 20th July 1989, at 11:00 AM', maxsplit=1))
# Результат:
# ['Good', 'better', 'Best']
# ['Book', 's', 'books', 'Books']
# ['Born', 'On', '20th', 'July', '1989', 'at', '11', '00', 'AM']
# ['Born On ', 'th July ', ', at ', ':', ' AM']
# ['Born On ', 'th July 1989, at 11:00 AM']

re.sub()

Здесь значение «sub» — это сокращение от substring, т.е. подстрока. В данном методе исходный шаблон сопоставляется с заданной строкой и, если подстрока найдена, она заменяется параметром repl.

Кроме того, у метода есть дополнительные аргументы. Это count, счетчик, в нем указывается, сколько раз заменяется регулярное выражение. А также flag, в котором мы можем указать флаг регулярного выражения (например, re.IGNORECASE)

Синтаксис: re.sub(шаблон, repl, строка, count = 0, flags = 0)

В результате работы кода возвращается либо измененная строка, либо исходная.

Посмотрим на работу метода на следующем примере.

 
import re
# Шаблон 'lly' встречается в строке в "successfully" и "DELLY"
print(re.sub('lly', '#$', 'doctor appointment booked successfully in DELLY'))
# Благодаря использованию флага регистр игнорируется, и 'lly' находит два совпадения
# Когда совпадения найдены, 'lly' заменяется на '~*' в "successfully" и "DELLY".
print(re.sub('lly', '#$', 'doctor appointment booked successfully in DELLY', flags=re.IGNORECASE))
# Чувствительность к регистру: 'lLY' не находит совпадений, и ничего в строке не будет заменено
print(re.sub('lLY', '#$', 'doctor appointment booked successfully in DELLY'))
# С count = 1 заменяется только одно совпадение с шаблоном
print(re.sub('lly', '#$', 'doctor appointment booked successfully in DELLY', count=1, flags=re.IGNORECASE))

re.

subn()

Функциональность subn() во всех отношениях такая же, как и sub(). Единственная разница – это формат вывода. subn() возвращает кортеж, содержащий общее количество замен и новую строку.

Синтаксис: re.subn(шаблон, repl, строка, count = 0, flags = 0)

Рассмотрим такой пример.

import re
print(re.subn('lly', '#$', 'doctor appointment booked successfully in DELLY'))
t = re.subn('lly', '#$', 'doctor appointment booked successfully in DELLY', flags=re.IGNORECASE)
print(t)
print(len(t))
# Это даст такой же вывод, как и sub()
print(t[0])

re.escape()

Этот метод возвращает строку с обратной косой чертой \ перед каждым не буквенно-числовым символом. Это полезно, если мы хотим сопоставить произвольную буквенную строку, которая может содержать метасимволы регулярного выражения. Numberic class»))

Заключение

Сегодня мы поговорили о регулярных выражениях в Python и о том, что необходимо для их понимания в любом приложении. Мы изучили различные методы и метасимволы, присутствующие в регулярных выражениях Python, на примерах.

Регулярные выражения в Python: необходимый запас знаний | by Jenny V | NOP::Nuances of Programming

Регулярные выражения представляют собой последовательность знаков и символов, которые в глазах неподготовленного человека выглядят также устрашающе, как и уличные вывески на иностранном языке. С этой точки зрения, нельзя не заметить иронию в самом термине “регулярные выражения”.

Любой ценой я избегал с ними встречи, и эта игра в прятки затянулась намного дольше, чем можно себе представить. Но однажды я решил, что пора с ними подружиться.

Регулярные выражения — это чрезвычайно важная часть деятельности программиста и полезный инструмент в рабочем арсенале. Они избавляют от необходимости часами сидеть за написанием неоправданно длинного кода.

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

Работа с регулярными выражениями напоминает изучение иностранного языка: как только приходит понимание слов и грамматики — начинаешь без труда составлять предложения.

В самом общем смысле регулярные выражения — это последовательности символов для поиска соответствий шаблону. Они являются экземплярами регулярного языка и широко применяются для парсинга текста или валидации входных строк.

Представьте лист картона, в котором вырезаны определенные фигуры. И только фигуры, точь-в-точь соответствующие вырезам, смогут через них пройти. В данном случае лист картона аналогичен строке регулярного выражения.

Как выглядел бы поисковый шаблон с регулярным выражением для рассмотренного примера?

Regex: circle|triangle|hexagon

Инструкция ввода задает три входящие фигуры: круг, треугольник и прямоугольник.

Движок регулярного выражения обнаружит совпадения только слов circle и triangle. На сервисе Regex101 вы можете сами в этом убедиться.

Все просто!

Сами по себе регулярные выражения являются неотъемлемой частью регулярного языка. Однако их поддерживают большинство актуальных языков программирования, которые располагают встроенными (или доступными для скачивания) модулями.

Таким образом, появляется возможность использовать их в наших рабочих языках. Помимо ссылок на regex101, встречающихся по ходу статьи, во всех примерах кода будет применяться модуль регулярных выражений Python re.

Как же переложить на код этот метафорический образ листа картона? Обратимся к примеру.

Дана строка “Sylvie is 20 years old” (“Сильвии 20 лет”), и нужно извлечь из предложения только возраст, т.е. исключительно число. Для этой цели существует шаблон регулярного выражения \d — специальный символ, который соответствует только шаблонам, содержащим цифры (подробным разбором займемся позже).

# Импортируем библиотеки 
import re
txt =  "Sylvie is 20 years old."
# Регулярное выражение для извлечения чисел из строки 
age = re.findall(r'\d', txt)
print(age)

Вывод:

Не совсем то, что нужно, но первый шаг навстречу цели уже сделан. По крайней мере, цифры обнаружены! Их распознал блок, вырезанный из красного картона.

В зависимости от условия он может в буквальном смысле варьироваться от одного буквенного символа алфавита (например, регулярное выражение a что ни на есть верное и предназначено для поиска a внутри строкового ввода) до группы специальных символов. Как мы увидим далее, они представлены в большом разнообразии.

Однако требуется получить не отдельные цифры, а целое число. Немного преобразуем используемый идентификатор с помощью другого блока.

# Импортируем библиотеки 
import re
txt = "Sylvie is 20 years old."
# Получаем только двузначные числа 
age = re.findall(r'\d{2}', txt)
print(age)

Вывод:

Отлично! Мы получили возраст Сильвии из строки! Стоп, а если бы в ней также был указан год рождения? При использовании вышеприведенного выражения результатом стали бы все двузначные варианты чисел в предложении.

Поскольку это не входит в наши планы, то подумаем о внесении дальнейших изменений.

Добавляем граничное выражение, поскольку требуемое двузначное число окружено с обеих сторон пробелами.

# Импортируем библиотеки 
import re
txt =  "Sylvie is 20 years old, she was born in the year 2001"
# Получаем только числа 
age = re.findall(r'\b\d{2}\b', txt)
print(age)

Бинго:

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

без границ;

с указанием границ.

Довольно аккуратно, не так ли? С помощью минимального однострочного кода мы извлекли число из строки.

Как уже ранее упоминалось, существует множество символов для создания в коде виртуальных аналогов таких вырезанных блоков. Пора с ними познакомиться.

Символы

  • \d: цифровой символ от 0 до 9;
  • \D: любой нецифровой символ;
  • \s: пробельный символ;
  • \S: любой непробельный символ;
  • \w: любой символ;
  • \W: любой не цифро-буквенный символ;
  • \b: определяет границы слова;
  • . : обозначает любой символ; (пример)
  • \. : соответствует точке.

Модификаторы

  • {}: группировка числовых значений. Например, \d{3} дает совпадения, включающие 3 цифры, а \d{3,5} — совпадения, содержащие от 3 до 5 цифр. По сути, это {min, max}.
  • []: группировка символов. Соответствует одному из символов в скобках. Например, [a-z] выдаст совпадения с каждым символом алфавита в нижнем регистре.
  • +: соответствует предыдущему элементу один или более раз. Например, [a-z]+a сгруппирует результат совпадений, как показано в примере.
  • ?: соответствует предыдущему элементу 0 или один раз. Здесь можно посмотреть принцип действия [a-z]?a.
  • *: соответствует предыдущему элементу 0 или множество раз. Обратимся к примеру [a-z]*a. : указывает на начало строки.
  • |: оператор или. Например, col(o|u)r соответствует и американскому, и британскому вариантам написания слова color.

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

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

Принцип работы регулярных выражений

Существует 2 типа движков regex: первые ориентированы на текст, а вторые, наиболее распространенные, — на регулярные выражения. Вполне возможно, что вы с ними то как раз и работаете. Проведем простой тест с помощью Python для проверки используемого типа:

import re
pattern = "regex|regex not"
output = re. findall(pattern, "regex not")
print(output)

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

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

import re
pattern = r"dragon|fly|ing"
output = re.findall(pattern, "The dragonfly became friends with the flying dragon")
print(output)

Как видим, поиск совпадений происходит слева направо. Освоение этих азов определенно поможет в дальнейшей работе.

А теперь, вооружившись новыми знаниями, применим их на практике. Перечислим несколько случаев применения регулярных выражений:

  • парсинг входных данных, например текста, логов, веб-информации и т. д.;
  • валидация пользовательского ввода;
  • тестирование результатов вывода;
  • поиск текста;
  • реструктуризация данных.

Однако учиться лучше всего на примерах. Теперь, когда мы знаем принципы действия регулярных выражений и значения символов рассекречены, рассмотрим 3 конкретных ситуации их использования с помощью нескольких строк кода.

Пример 1. Валидация адресов электронной почты

В любом руководстве по регулярным выражениям данный пример встречается по умолчанию. Он представляет собой аналог “Hello World”, поэтому ему суждено быть в этом разделе. Его задача — проверять форматы вводимых адресов электронной почты.

Пошагово рассмотрим решение задачи. Во-первых, мы (зачастую) знаем, как выглядят корректные адреса e-mail:

[email protected]

Имя пользователя или someone обычно состоит из букв алфавита или комбинации цифр. Иногда могут встречаться и специальные символы, но новичкам в мире регулярных выражений лучше начать с простого примера.

Итак, у нас есть символы от a до z, цифры от 0 до 9, а также заглавные буквы в диапазоне A-Z. Регулярное выражение данной группы выглядит следующим образом:

[a-zA-Z0–9]

Аналогично, служба электронной почты обычно имеет буквенное обозначение, например Gmail, gmx, Hotmail, и следует за знаком @. Следовательно:

@[a-zA-Z]

На завершающем этапе рассмотрим наиболее известные домены — com, net, edu и org — которые указываются после знака точки вслед за провайдером службы электронной почты.

\.(com|net|edu|org)

Объединяя все вместе, получаем регулярное выражение:

[a-zA-Z0–9]+@[a-zA-Z]+\.(com|net|org|edu)

Теперь применим его в скрипте Python, который принимает на входе id электронной почты и проверяет его на соответствие требованиям формата.

# Импортируем библиотеки 
import re
'''
В данном примере рассматривается обобщенный шаблон e-mail: 
[email protected]
'''
# Определяем допустимые шаблоны ввода электронной почты 
pattern_email = r"[a-zA-Z0-9]+@[a-zA-Z]+\. (com|net|org|edu)"
#Создаем поле для ввода адреса электронной почты 
user_input = input()
if (re.search(pattern_email, user_input)):
print(f"{user_input} is a valid email.")
else:
print(f"{user_input} is invalid.")

Полученный результат выглядит следующим образом:

Теперь вы стали обладателем своего собственного валидатора id электронной почты.

Пример 2. Извлечение имен и значений возраста из текста

Ранее уже был рассмотрен упрощенный пример получения возраста из строки. В этом разделе научимся извлекать имена/текст и вносить их в словарь.

Нам уже известно, как с помощью регулярного выражения \b\d{2}\b извлечь двузначное число из строки. В случае с текстом в данном примере поработаем с 2 или 3 цифрами (из-за присутствия величины, обозначающей столетие).

Что касается процедуры получения имен из текста, то, как видим, каждое из них состоит из более 3 букв. В связи с этим, с задачей должны справиться группы строк с заглавными буквами длиной в 3 и более символов:

\b[A-z][a-z]{3,}\b

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

# Импортируем библиотеки 
import re
txt =  "Sylvie is 20 years old, her father, Christoph, is 55.\
Her grandfather Johannes was born at the end of WW-1 in 1918.\
He was 100 years old when he died in 2018"
'''
Поскольку указанный в тексте возраст состоит из 2 или 3 цифр, то используется регулярное выражение \d{2,3}. Оно с двух сторон ограничено \b, поскольку нам не нужны группы из 2 или 3 цифр, полученные из числа 1918. 
С именами в данном тексте все просто. Вполне сработает поиск всех слов, начинающихся с заглавных букв и содержащих более 3 символов. Делаем это также с границами.
'''
ages = re.findall(r'\b\d{2,3}\b', txt)
names = re.findall (r'\b[A-Z][a-z]{3,}\b',txt)
print(dict(zip(names, ages)))

Результат:

Конечно же, по мере усложнения входного текста и необходимости извлечения большего объема информации более рациональным путем, придется прибегать к дополнительным средствам помимо регулярных выражений. Однако могу вас заверить, что даже в сложных случаях этот инструмент обязательно пригодится в той или иной степени для упрощения.

Пример 3. Сопоставление пароля с шаблоном

Большинство из вас наверняка встречали такое предложение при создании нового пароля:

“Для гарантии надежности пароль должен состоять как минимум из 8 символов, в число которых должны входить, по крайней мере, по одной заглавной и строчной букве, цифре и одному специальному символу”.

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

Одна из частей задачи не вызывает сложности, так как основана на ранее изученном материале. Потребуются символы (верхнего и нижнего регистров) — A-Z и a-z, цифры — \d и специальные символы — _@$!%*?&, которые в сумме составляют строку длинной более 8 единиц:

[A-Za-z\d_@$!%*?&]{8,}

Это гарантирует совпадения со всеми вариантами, включающими любые из перечисленных выше символов.

Например, asdf@1234 станет верным паролем даже без заглавной буквы. Пример.

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

Позиционная проверка бывает двух типов:

Опережающая

  • Позитивная опережающая проверка. Она проводится с использованием в строке символов ?=. Например, xyz(?=abc) предварительно просматривает все xyz, проверяя наличие abc и выявляя соответствия только при его обнаружении (Пример).
  • Негативная опережающая проверка. Аналогична предыдущей, но с помощью утверждения ?! выполняющая противоположную задачу. В этом случае xyz(?!abc) предварительно просматривает все xyz, проверяя отсутствие abc, и выдает совпадения соответственно результатам (Пример).

Ретроспективная

  • Позитивная ретроспективная проверка. В данной ситуации движок регулярных выражений временно работает в обратном направлении. (?<=abc)xyz ищет все xyz, которым предшествует abc, а именно справа налево (Пример).
  • Негативная ретроспективная проверка похожа на предыдущий вариант, но (?<!abc)xyz уже ищет все xyz, которым не предшествует abc, а именно справа налево (Пример).

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

Рассмотрим все поэтапно. Для соответствия опережающей проверке необходимы заглавные буквы. (?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$»

# Используем getpass вместо стандартной функции ввода
# Это позволит скрыть запись как в реальной жизни

user_input = getpass.getpass()

invalid_pass_text = \
«Your password must have at least 8 characters,\
at least an upper case letter,\
a lowercase letter, a number, \
and a symbol so as to be secure»

if (re.search(pattern_password, user_input)):
print(«Strong Password Set»)
else:
print(invalid_pass_text)

Результат выглядит следующим образом (с паролями abcABC@1234 и abcABC1234):

Проверка надежности пароля, реализованная с помощью с регулярных выражений

Читайте также:

  • Шпаргалка по регулярным выражениям. В примерах
  • Python. Пять уловок, которые нужно знать, уже сегодня
  • Почему не стоит использовать or для проверки нескольких условий в Python

Читайте нас в Telegram, VK и Яндекс.Дзен

Перевод статьи Krupesh Raikar: Everything You Need To Know About Regular Expressions in Python

Python PIP

❮ Предыдущий Далее ❯

Что такое PIP?

PIP — это менеджер пакетов Python или модулей, если хотите.

Примечание: Если у вас Python версии 3.4 или выше, PIP включен по умолчанию.

Что такое пакет?

Пакет содержит все файлы, необходимые для модуля.

Модули — это библиотеки кода Python, которые вы можете включить в свой проект.

Проверить, установлен ли PIP

Перейдите в командной строке к каталогу сценариев Python и введите следующее:

Пример

Проверить версию PIP:

C:\Users\ Ваше имя \AppData\Local\Programs\Python\Python36- 32\Scripts>pip —version

Установить PIP

Если у вас не установлен PIP, вы можете загрузить и установить его с этой страницы: https://pypi.org/project/pip/

Загрузить пакет

Загрузить пакет очень просто.

Откройте интерфейс командной строки и скажите PIP загрузить пакет, который вы хотеть.

Перейдите в командной строке к каталогу сценариев Python и введите следующее:

Пример

Загрузите пакет с именем «camelcase»:

C:\Users\ Ваше имя \AppData\Local\Programs\ Python\Python36-32\Scripts>пип install camelcase

Теперь вы загрузили и установили свой первый пакет!

Использование пакета

После установки пакет готов к использованию.

Импортируйте пакет «camelcase» в свой проект.

Пример

Импорт и использование «camelcase»:

import camelcase

c = camelcase.CamelCase()

txt = «hello world»

print(c.hump(txt))

Пример запуска »

Поиск пакетов

Дополнительные пакеты можно найти на https:// pypi.org/.

Удаление пакета

Использование удаления 9Команда 0089 для удаления пакета:

Пример

Удалите пакет с именем «camelcase»:

C:\Users\ Ваше имя \AppData\Local\Programs\Python\Python36-32\Scripts>pip uninstall camelcase

Диспетчер пакетов PIP попросит вас подтвердить, что вы хотите удалить пакет camelcase:

Удаление camelcase-02.1:
  Будет удалено:
    c:\users\ Ваше имя \appdata\local\programs\python\python36-32\lib\site-packages\camelcase-0.2-py3.6 .egg-информация
c:\users\ Ваше имя \appdata\local\programs\python\python36-32\lib\site-packages\camelcase\*
Продолжить (y/n)?

Нажмите y , и пакет будет удален.

Список пакетов

Используйте команду list для вывода списка всех пакетов, установленных в вашей системе:

Пример

Список установленных пакетов:

C:\Users\ Ваше имя \Programs\Local Python\Python36-32\Scripts>список пунктов

Результат:

Пакет         Версия
-----------------------
camelcase       0.2
mysql-connector 2.1.6
pip 18.1
pymongo         3.6.1
setuptools      39.0.1

❮ Предыдущая Следующий ❯


ВЫБОР ЦВЕТА

Лучшие учебники
Учебник HTML
Учебник CSS
Учебник JavaScript
Учебник How To
Учебник SQL
Учебник Python
Учебник W3.CSS
Учебник по Bootstrap
Учебник по PHP
Учебник по Java
Учебник по C++
Учебник по jQuery

Лучшие ссылки
HTML Reference
CSS Reference
JavaScript Reference
SQL Reference
Python Reference
W3. CSS Reference
Bootstrap Reference
PHP Reference
HTML Colors
Java Reference
Angular Reference
jQuery Reference


4 Top5 Examples Примеры HTML
Примеры CSS
Примеры JavaScript
How To Примеры
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery

FORUM | О

W3Schools оптимизирован для обучения и обучения. Примеры могут быть упрощены для улучшения чтения и обучения. Учебники, ссылки и примеры постоянно пересматриваются, чтобы избежать ошибок, но мы не можем гарантировать полную правильность всего содержания. Используя W3Schools, вы соглашаетесь прочитать и принять наши условия использования, куки-файлы и политика конфиденциальности.

Copyright 1999-2023 Refsnes Data. Все права защищены.
W3Schools работает на основе W3.CSS.

Регулярные выражения Python — Памятка по Python

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

Регулярное выражение (сокращенно регулярное выражение [. ..]) — это последовательность символов, определяющая шаблон поиска в тексте. [...] используется алгоритмами поиска строк для операций «найти» или «найти и заменить» над строками или для проверки ввода.

  1. Импорт модуля регулярного выражения с импорт относительно .
  2. Создайте объект Regex с помощью функции re.compile() . (Не забудьте использовать необработанную строку.)
  3. Передайте строку, которую вы хотите найти, в метод search() объекта Regex. Это возвращает объект Match .
  4. Вызовите метод group() объекта Match, чтобы вернуть строку фактического сопоставленного текста.

Все функции регулярных выражений в Python находятся в модуле re:

 >>> import re

Символы регулярных выражений

Символ Совпадения
? ноль или один из предыдущей группы.
* ноль или более из предыдущей группы.
+ один или несколько из предыдущей группы.
{n} ровно n из предыдущей группы.
{н,} 9spam означает, что строка должна начинаться со спама.
spam$ означает, что строка должна заканчиваться спамом.
. любой символ, кроме символов новой строки.
\d , \w и \s цифра, слово или пробел соответственно.
\D , \W и \S все, кроме цифры, слова или пробела соответственно. 9abc] любой символ, не заключенный в скобки.

Совпадающие объекты регулярного выражения 

 >>> phone_num_regex = re. compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> mo = phone_num_regex.search('Мой номер 415-555-4242.')
>>> print(f'Найден номер телефона: {mo.group()}')
# Найден номер телефона: 415-555-4242

Группировка скобками 

 >>> phone_num_regex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
>>> mo = phone_num_regex.search('Мой номер 415-555-4242.')
>>> мо.групп(1)
# '415'
>>> мо.групп(2)
# '555-4242'
>>> мо.групп(0)
# '415-555-4242'
>>> мо.группа()
# '415-555-4242'

Чтобы получить все группы одновременно, используйте метод groups() :

 >>> mo.groups()
('415', '555-4242')
>>> area_code, main_number = mo.groups()
>>> печать (код_зоны)
415
>>> печать (основной_номер)
555-4242

Несколько групп с трубой

Вы можете использовать | символов в любом месте, где вы хотите сопоставить одно из многих выражений.

 >>> hero_regex = re.compile (r'Бэтмен|Тина Фей')
>>> mo1 = hero_regex.search('Бэтмен и Тина Фей. ')
>>> мо1.группа()
# 'Бэтмен'
>>> mo2 = hero_regex.search('Тина Фей и Бэтмен.')
>>> mo2.группа()
# 'Тина Фей'

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

 >>> bat_regex = re.compile(r'Bat(man|mobile|copter|bat)')
>>> mo = bat_regex.search('Бэтмобиль потерял колесо')
>>> мо.группа()
# 'Бэтмобиль'
>>> мо.групп(1)
# 'мобильный'

Необязательное совпадение с вопросительным знаком

? Символ помечает предшествующую ему группу как необязательную часть шаблона.

 >>> bat_regex = re.compile(r'Bat(wo)?man')
>>> mo1 = bat_regex.search('Приключения Бэтмена')
>>> мо1.группа()
# 'Бэтмен'
>>> mo2 = bat_regex.search('Приключения Бэтвумен')
>>> mo2.группа()
# 'Бэтвумен'

Совпадение нуля или более со звездочкой

* (звездочка или звездочка) означает «совпадение нуля или более». Группа, предшествующая звездочке, может встречаться в тексте любое количество раз.

 >>> bat_regex = re.compile(r'Bat(wo)*man')
>>> mo1 = bat_regex.search('Приключения Бэтмена')
>>> мо1.группа()
'Бэтмен'
>>> mo2 = bat_regex.search('Приключения Бэтвумен')
>>> mo2.группа()
"Бэтвумен"
>>> mo3 = bat_regex.search('Приключения Бэтвововумен')
>>> mo3.группа()
"Батвововумен"

Совпадение одного или нескольких с Plus

+ (или плюс) означает совпадение одного или нескольких . Группа, предшествующая плюсу, должна встречаться хотя бы один раз:

 >>> bat_regex = re.compile(r'Bat(wo)+man')
>>> mo1 = bat_regex.search('Приключения Бэтвумен')
>>> мо1.группа()
# 'Бэтвумен'
>>> mo2 = bat_regex.search('Приключения Бэтвововумен')
>>> mo2.группа()
# 'Бэтвувовумен'
>>> mo3 = bat_regex.search('Приключения Бэтмена')
>>> mo3 нет
# Истинный

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

Если у вас есть группа, которую вы хотите повторить определенное количество раз, укажите в регулярном выражении номер группы в фигурных скобках:

 >>> ha_regex = re. compile( г'(Га){3}')
>>> mo1 = ha_regex.search('ХаХаХа')
>>> мо1.группа()
# 'Ха-ха-ха'
>>> mo2 = ha_regex.search('Ha')
>>> mo2 нет
# Истинный

Вместо одного числа можно указать диапазон с минимумом и максимумом в фигурных скобках. Например, регулярное выражение (Ха){3,5} будет соответствовать «ХаХаХа», «ХаХаХаХа» и «ХаХаХаХа».

 >>> ha_regex = re.compile(r'(Ha){2,3}')
>>> mo1 = ha_regex.search('ХаХаХаХа')
>>> мо1.группа()
# 'Ха-ха-ха'

Жадное и нежадное сопоставление

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

 >>> greedy_ha_regex = re.compile(r'(Ha){3,5}')
>>> mo1 = greedy_ha_regex.search('Ха-Ха-Ха-Ха')
>>> мо1.группа()
# 'Ха-Ха-Ха-Ха'
>>> non_greedy_ha_regex = re. compile(r'(Ha){3,5}?')
>>> mo2 = non_greedy_ha_regex.search('Ха-Ха-Ха-Ха')
>>> mo2.группа()
# 'Ха-ха-ха'

Метод findall()

Метод findall() возвращает строки каждого совпадения в искомой строке.

 >>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # не имеет групп
>>> phone_num_regex.findall('Мобильный: 415-555-9999 Рабочий: 212-555-0000')
# ['415-555-9999', '212-555-0000']

Создание собственных классов персонажей

Вы можете определить свой собственный класс персонажей с помощью квадратных скобок. Например, класс символов [aeiouAEIOU] будет соответствовать любой гласной, как строчной, так и прописной.

 >>> vowel_regex = re.compile(r'[aeiouAEIOU]')
>>> vowel_regex.findall('Робокоп ест детское питание. ДЕТСКОЕ ПИТАНИЕ.')
# ['о', 'о', 'о', 'е', 'а', 'а', 'о', 'о', 'А', 'О', 'О']

Можно также включать диапазоны букв или цифр, используя дефис. Например, класс символов [a-zA-Z0-9] будет соответствовать всем строчным буквам, прописным буквам и цифрам.

Поместив знак вставки ( 9\д+#39;) >>> integer_string_is_num.search(‘1234567890’) # <_sre.SRE_Match объект; диапазон = (0, 10), совпадение = '1234567890'> >>> whole_string_is_num.search(‘12345xyz67890′) — None # Истинный >>> integer_string_is_num.search(’12 34567890’) — None # Истинный

Подстановочный знак

. Символ (или точка) в регулярном выражении будет соответствовать любому символу, кроме символа новой строки:

 >>> at_regex = re.compile(r'.at')
>>> at_regex.findall('Кот в шляпе сел на плоский коврик.')
['кошка', 'шляпа', 'сидел', 'лат', 'циновка']

Сопоставление всего с Dot-Star 

 >>> name_regex = re.compile(r'Имя: (.*) Фамилия: (.*)')
>>> mo = name_regex.search('Имя: Аль Фамилия: Свейгарт')
>>> мо.групп(1)
# 'Эл'
>>> мо.групп(2)
"Свейгарт"

.* использует жадный режим: он всегда будет пытаться сопоставить как можно больше текста. Чтобы сопоставить любой текст без жадности, используйте точку, звездочку и вопросительный знак ( . *? ). Знак вопроса указывает Python на нежадное сопоставление:

 >>> non_greedy_regex = re.compile(r'<.*?>')
>>> mo = non_greedy_regex.search('<Подать мужчине> на обед.>')
>>> мо.группа()
# '<Служить человеку>'
>>> greedy_regex = re.compile(r'<.*>')
>>> mo = greedy_regex.search('<Подать мужчине> на обед.>')
>>> мо.группа()
# '<Подать мужчине> на ужин.>'

Сопоставление новой строки с символом точки

Точка-звезда будет соответствовать всему, кроме новой строки. Проходя re.DOTALL в качестве второго аргумента для re.compile() , вы можете сделать так, чтобы символ точки соответствовал всем символам, включая символ новой строки:

 >>> no_newline_regex = re.compile('.*')
>>> no_newline_regex.search('Служить общественному доверию.\nЗащищать невиновных.\nСоблюдать закон.').group()
# 'Служить общественному доверию.'
>>> newline_regex = re.compile('.*', re.DOTALL)
>>> newline_regex.search('Служить общественному доверию. \nЗащищать невиновных.\nСоблюдать закон.').group()
# 'Служить общественному доверию.\nЗащищать невиновных.\nСоблюдать закон.'

Сопоставление без учета регистра

Чтобы сделать ваше регулярное выражение нечувствительным к регистру, вы можете передать re.IGNORECASE или re.I в качестве второго аргумента для re.compile() :

 >>> robocop = re.compile(r'robocop', re.I)
>>> robocop.search('Робокоп наполовину человек, наполовину машина, наполовину полицейский.').group()
# 'Робокоп'
>>> robocop.search('РОБОКОП защищает невиновных.').group()
# 'РОБОкоп'
>>> robocop.search('Ал, почему в твоей книге по программированию так много говорится о робокопе?').group()
# 'робокоп'

Замена строк с помощью метода sub()

Методу sub() для объектов Regex передаются два аргумента:

  1. Первый аргумент — это строка для замены любых совпадений.
  2. Второй — это строка для регулярного выражения.

    No related posts.