📦 Репозиторий занятия 60

"""
1. Язык регулярных выражений - это самостоятельный макроязык.
    Как, например, SQL.
    (впрочем, некоторые считают его всего лишь "формальным языком шаблонов")

2. Этот макроязык используется в большинстве языков высокого уровня.
    (в той или иной степени).


Зачем он вообще нужен?

1. Чтобы очень легко и удобно "вытащить" из текста ровно то, что нам нужно.
2. Чтобы проверить, действительно ли в тексте есть то, что нам нужно.
3. Чтобы быстро и удобно заменить в тексте ненужное на нужное.
4. Чтобы легко и удобно разбить текст по сложным правилам.


С основными элементами макроязыка регулярных выражений (regex) можно ознакомиться здесь:
https://it4each.com/blog/reguliarnye-vyrazheniia-predislovie/


Ниже пример простейшего поиска кол-ва повторений паттерна в тексте.
Это делается на чистом Python без всякого regex.
Поскольку задача очень простая.

Но если вместо pattern использовать регулярное выражение,
то можно получить ГОРАЗДО более интересные результаты.
"""

from lorem_text import lorem

# print(lorem.paragraph())

text = """Consequatur est quos repellat obcaecati, corporis corrupti cupiditate qui 
tempore nesciunt possimus dolores animi voluptates culpa suscipit, eum excepturi 
laboriosam nemo commodi ullam? Odit placeat nemo sint voluptatum in illum accusamus 
saepe asperiores, distinctio odio harum? Dignissimos necessitatibus quaerat modi, 
magni ex debitis voluptas, neque error totam odit, molestias odio voluptatem obcaecati 
minus vel nostrum repudiandae iure, blanditiis corporis corrupti ducimus aperiam.
"""

patten = r'mo'

print(text.count(patten))  # 6

import re

TEXT = """ 111 22 33-aad 232-15-11 ff 15 
15 555-22-78 223/99-37 223/25/987 123-35 26 258-85-45 
"""

pattern = r'\d{3}-\d{2}-\d{2}|\d{3}\/\d{2}\/\d{2}|\d{3} \d{2} \d{2}'

"""С применением регулярных выражений в конкретных методах Python-пакета re, 
нужно быть очень внимательными - у каждого метода могут быть свои особенности.

То, что сработало в regex101 - совсем не факт, что сработает в каждом re-методе!

findall() - отлично работает с паттернами без группировки
"""

pattern_without_group = r'\d{3}-\d{2}-\d{2}|\d{3}\/\d{2}\/\d{2}|\d{3} \d{2} \d{2}'
result = re.findall(pattern_without_group, TEXT)
print(result)
# ['111 22 33', '232-15-11', '555-22-78', '223/25/98', '258-85-45']

"""
Однако, добавление группировки всё сводит на нет:
"""
pattern_group = r'\d{3}(-| |\/)\d{2}\1\d{2}'

result = re.findall(pattern_group, TEXT)
print(result)
# [' ', '-', '-', '/', '-']

"""
Решение 1:
Окружить результат ещё одной группировкой.
(ОБРАТИТЕ ВНИМАНИЕ: 
    - теперь группировка разделителей становится по счёту второй
    - дополнительно ещё придётся обрабатывать и tuple группировок)
"""

pattern_double_group = r'(\d{3}(-| |\/)\d{2}\2\d{2})'

intermediate_result = re.findall(pattern_double_group, TEXT)
print(intermediate_result)
# [('111 22 33', ' '), ('232-15-11', '-'), ('555-22-78', '-'), ('223/25/98', '/'), ('258-85-45', '-')]

result = [x[0] for x in intermediate_result]
print(result)
# ['111 22 33', '232-15-11', '555-22-78', '223/25/98', '258-85-45']

"""
Решение 2:
Для группировок использовать более сложный метод finditer()
"""

for item in re.finditer(pattern_group, TEXT):
    print(item)

result = [match.group(0) for match in re.finditer(pattern_group, TEXT)]
print(result)
# ['111 22 33', '232-15-11', '555-22-78', '223/25/98', '258-85-45']

import re

TEXT = """111 22 33-aad 232-15-11 ff 15 
15 555-22-78 223/99-37 223/25/987 123-35 26 258-85-45 
"""

pattern = r'\d{3} \d{2} \d{2}|\d{3}-\d{2}-\d{2}|\d{3}\/\d{2}\/\d{2}'

""" re.search - если находит совпадение, возвращает полную информацию
Если не находит - возвращает None
"""

match = re.search(pattern, TEXT)
print(match.group())  # 111 22 33

match = re.search(r'asdfasdfasdf', TEXT)
print(match)  # None


""" re.match - проверка СТРОГО с начала строки
Если находит совпадение, возвращает полную информацию
Если не находит - возвращает None
"""

match = re.match(pattern, TEXT.lstrip())
print(match.group())  # 111 22 33


# Сдвигаем строку на пробел и получаем ошибку,
# так как совпадения, начиная с начала строки, больше нет
match = re.match(pattern, '  ' + TEXT)
print(match)  # None

""" re.sub(<паттерн поиска>, <паттерн замены>, <строка>)"""

import re

pattern = r"(\b\w+)\s\1"
text = "hello hello world world"

result = re.findall(pattern, text)
print(result)  # ['hello', 'world']

""" re.sub заменяет все вхождения шаблона pattern на указанный текст.

В данном случае, каждый раз, когда шаблон находит два повторяющихся слова, 
он заменяет их на первое слово (\1), окруженное ***.

Таким образом, строка "hello hello world world" преобразуется в "hello world".
"""

replaced_text = re.sub(pattern, r"***\1***", text)
print(replaced_text)
# ***hello*** ***world***


# re.subn() - не только находит и заменяет, но и подсчитывает число замен
replaced_text_and_count = re.subn(pattern, r"***\1***", text)
print(replaced_text_and_count)
# ('***hello*** ***world***', 2)


"""Что надо сделать, если мы хотим окружить КАЖДОЕ слово,
причём независимо от регистра.
"""
new_pattern = r"(\b[a-z]+\b)"
new_text = "Hello hello world worLd"
replaced_text = re.sub(new_pattern, r"***\1***", new_text, flags=re.IGNORECASE)
print(replaced_text)

Оператор "walrus" (`:=`), введённый в Python 3.8, позволяет присваивать значение переменной внутри выражений.  

### 1. В цикле `while`
Один из самых популярных случаев использования оператора `walrus` — это чтение данных в цикле, когда нужно присваивать значение переменной и использовать его сразу в условии.

```
# Пример с циклом while
while (n := len(input_string)) > 0:
    print(f"Длина строки: {n}")
    input_string = input_string[:-1]
```

Здесь строка получает свою длину и сразу проверяется в условии, с присваиванием этого значения переменной `n`.

### 2. В условных выражениях (if)
Можно использовать `walrus` внутри условия `if`, чтобы не вызывать функцию или выражение дважды.

```
# Пример с условием if
if (num := len(my_list)) > 5:
    print(f"Список слишком длинный! Длина: {num}")
```

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

### 3. В list comprehensions (и прочих comprehensions при фильтрации данных)
Оператор `walrus` также может быть полезен внутри list comprehension, чтобы выполнять вычисления и присваивания в одном выражении.

```
# Пример с list comprehension
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
squared = [square for num in numbers if (square := num ** 2) > 20]
print(squared)  # Выведет [25, 36, 49, 64, 81]
```

Здесь для каждого элемента списка `numbers` мы сразу вычисляем квадрат и сохраняем его в переменную `square`,  
затем проверяем, больше ли он 20, и добавляем в новый список.


### 4. В функциях
Оператор `walrus` нельзя использовать в определении параметров функции в Python.

Например, следующий код вызовет ошибку:
```
# ⚠️ Неправильный пример
def my_function((x := 5)):
    print(x)
```
Этот код приведёт к синтаксической ошибке. Оператор walrus не поддерживается в местах, где ожидаются выражения для объявления параметров, таких как в определении функции.

Однако, мы можем использовать оператор walrus внутри тела функции или в выражениях. Например:

```
# Правильный пример
def my_function(input_string):
    if (length := len(input_string)) > 5:
        print(f"Длина строки: {length}")
    else:
        print("Строка слишком короткая")
```
…

# Иерархия объектов модуля `re`

```
re (модуль)
├── Методы
│   ├── search()       → Match or None          → Находит первое совпадение в строке 
│   ├── match()        → Match or None          → Проверяет начало строки
│   ├── fullmatch()    → Match or None          → Проверяет, соответствует ли вся строка
│   ├── findall()      → list[str or tuple]     → Возвращает все совпадения в виде списка
│   ├── finditer()     → iterator[Match]        → Возвращает итератор Match-объектов  
│   ├── sub()          → str                    → Заменяет по шаблону (аналог str.replace)  
│   ├── subn()         → (str, int)             → То же, что sub(), но возвращает ещё и число замен  
│   ├── split()        → list[str]              → Разделяет строку по шаблону (аналог str.split) 
│   ├── compile()      → Pattern object         → Компилирует строку шаблона в объект Pattern  
│   └── escape()       → str (экранирует        → Эквивалент raw-строки, где вручную добавлены   
│                             спец. символы)                            символы экранирования '\'
│
│
├── Константы-флаги
│   ├── re.IGNORECASE / re.I     → Игнорирует регистр (например, 'A' == 'a')
│   ├── re.MULTILINE / re.M      → ^ и $ работают в начале/конце каждой строки (а не всего текста)
│   ├── re.DOTALL / re.S         → Точка (.) захватывает и символ новой строки \n
│   ├── re.VERBOSE / re.X        → Позволяет писать шаблон с пробелами и комментариями (удобно для сложных regex)
│   ├── re.ASCII / re.A          → Символы \w, \b, \d и т.п. работают только с ASCII (не Unicode)
│   └── re.LOCALE                → Поведение \w, \W, \b и т.п. зависит от локали (устаревшее и редко используемое)
│                                        (пример установки локали: locale.setlocale(locale.LC_ALL, 'ru_RU.UTF-8'))
│
│                           ⚠️ Несколько флагов можно объединять с помощью символа "|" 
│                                (flags = re.IGNORECASE | re.DOTALL)
│
│
├── Объекты
│   ├── Pattern (скомпилированный шаблон)
│   │   ├── search()
│   │   ├── match()
│   │   ├── fullmatch()
│   │   ├── findall()
│   │   ├── finditer()
│   │   ├── sub()
│   │   ├── subn()
│   │   ├── split()
│   │   └── .pattern (атрибут, возвращающий шаблон регулярного выражения)
│   │
│   └── Match
│       ├── group([n])
│       ├── groups()
│       ├── groupdict()
│       ├── start([n])
│       ├── end([n])
│       ├── span([n])
│       └── .string (атрибут, возвращающий исходный текст)

```

## Методы

Принимают паттерн и текст, и возвращают результат в указанном виде

## Константы-флаги

…