#alg shake sort - улучшенный bubble sort, после вспытия большего поворачивает в обратную сторону перенося наименьшее значение в начало

def shake_sort(num_list: list[int]) -> list[int]:
    if len(num_list) < 2:
        return num_list
    low = 0
    high = len(num_list) - 1
    while low < high:
        for i in range(low, high):
            if num_list[i] > num_list[i + 1]:
                num_list[i], num_list[i + 1] = num_list[i + 1], num_list[i]
        high -= 1
        for i in range(high, low, -1):
            if num_list[i] < num_list[i - 1]:
                num_list[i], num_list[i - 1] = num_list[i - 1], num_list[i]
        low += 1
    return num_list

#alg even odd sort - улучшенный bubble sort, поочередно проходящий по парам начинающимся с четного индекса, на следующей итерации по парам нач с нечетных индексов.

def even_odd_sort(num_list: list[int]) -> list[int]:
    if len(num_list) < 2:
        return num_list
    even_odd_switch = 0
    low = 0
    high = len(num_list) - 1
    pure_sort_passing = []
    while len(pure_sort_passing) < 2:
        pure_sort_passing.append(even_odd_switch)
        for i in range(low + even_odd_switch, high, 2):
            if num_list[i] > num_list[i + 1]:
                num_list[i], num_list[i + 1] = num_list[i + 1], num_list[i]
                if even_odd_switch in pure_sort_passing:
                    pure_sort_passing.remove(even_odd_switch)
        even_odd_switch = 1 - even_odd_switch  # swap even to odd and vice versa.
    return num_list

#alg comb sort - сотрировка расческой

def comb_sort(num_list: list[int]) -> list[int]:
    if len(num_list) < 2:
        return num_list
    # Общепризнанный оптимальный фактор уменьшения
    reduction_factor = 1.247
    count = len(num_list)
    between_el_dist = count
    is_swap = True
    # если проходы с расстоянием больше 1 закончены, нужна финальная проверка классическим пузырьком
    # которая вызывается условием or between_el_dist > 1
    while is_swap or between_el_dist > 1:
        between_el_dist = max(1, int(between_el_dist // reduction_factor))

        high = count - between_el_dist

        is_swap = False
        for i in range(0, high):
            if num_list[i] > num_list[i + between_el_dist]:
                num_list[i], num_list[i + between_el_dist] = num_list[i + between_el_dist], num_list[i]
                is_swap = True
    return num_list

#alg insertion_sort - сортировка вставками

def insertion_sort(num_list: list[int]) -> list[int]:
    # моржовый оператор := позволяет внутри выражения присвоить переменную для дальнейшего использования 
    if (length := len(num_list)) < 2:
        return num_list

    for i in range(1, length):
        for j in range(i, 0, -1):
            if num_list[j - 1] > num_list[j]:
                num_list[j], num_list[j - 1] = num_list[j - 1], num_list[j]
            else:
                break
    return num_list

#alg selection_sort - сортировка выбором

def selection_sort(num_list: list[int]) -> list[int]:
    if (length := len(num_list)) < 2:
        return num_list

    for i in range(length):
        current_max_index = 0
        for j in range(length - i):
            if num_list[j] > num_list[current_max_index]:
                current_max_index = j
        # no swap if index don't changed
        if current_max_index != length - i - 1:
            num_list[length - i - 1], num_list[current_max_index] = num_list[current_max_index], num_list[length - i - 1]
    return num_list

#bot библиотеки для написания ботов

python-telegram-bot - синхронный, актив сообщество
aiogram - асинхронный, актив сообщество
telebot - прост, но сообщество менее активно
telethon - работает через mtproto, а не botapi, что может стать ограничением при масштабировании

внутри строк данные можно быстро редактировать с помощью (: + оператор ) перед выводом:

#указать количество цифр после запятой
price = 200.2010
digits_count_str = f'{price:.2f}' # Output 200.20

# Целые числа: :d Этот кейс мне кажется бесполезным, если убрать :d то
# вывод не поменяется, а семантику несет название переменной
int_str = f'{value:d}'

#Проценты: :.2% супер полезное свойство, переводит десятичную дробь в проценты с указанием знаков после запятой 
percent = 0.123132
perc_str =  f'{percent:.3%}' Output '12.313%'

# Отступы при выводе
# Пример с выравниванием влево
value = "Привет"
leveling_str = f'{value:<10}'  # "Привет    "
print(leveling_str)

# Пример с выравниванием вправо
value = "Мир"
leveling_str = f'{value:>10}'  # "       Мир"
print(leveling_str)

# Пример с центровкой
value = "Python"
leveling_str = f'{value:^10}'  # "  Python  "
print(leveling_str)

# Пример с числом
value = 42
leveling_str = f'{value:<5}'  # "42   "
print(leveling_str)

#linux #ubuntu

Какая оболочка в данный момент 
echo $SHELL или echo $0

изменить оболочку для пользователя 
chsh -s {путь до оболочки} {user}

#alg quick_sort - быстрая сортировка (сортировка Хоара). Выделяем опорный элемент pivot, относительно которого строим рекурсию, используем функцию для участков слева и справа от опорного, и так до мельчайших отсортированных списков.

def partition(left, right, num_list):
    pivot_index = random.randint(left, right)
    pivot_value = num_list[pivot_index]
    num_list[pivot_index], num_list[right] = num_list[right], num_list[
        pivot_index]  
    store_index = left  

    for i in range(left, right):
        if num_list[i] < pivot_value:  
            num_list[store_index], num_list[i] = num_list[i], num_list[store_index] 
            store_index += 1

    num_list[store_index], num_list[right] = num_list[right], num_list[store_index]
    return store_index 


def quick_sort_1(left: int, right: int, num_list: list[int]) -> list[int]:
    if left < right: 
        m = partition(left, right, num_list)
        quick_sort_1(left, m - 1, num_list)
        quick_sort_1(m + 1, right, num_list)
    return num_list  


def quick_sort_2(num_list: list[int]) -> list[int]:
    if (list_len := len(num_list)) <= 1:
        return num_list

    pivot = num_list[random.randint(0, list_len - 1)]

    left = list(filter(lambda x: x < pivot, num_list))
    center = list(filter(lambda x: x == pivot, num_list))
    right = list(filter(lambda x: x > pivot, num_list))

    return quick_sort_2(left) + center + quick_sort_2(right)

#教え
Видео 7/22 start -> 30:00

# Генераторы последовательностей или comprehensions

#пример генератора списка 
num_list = [ i for i in range(1,11) if i % 2 == 0]

#способы трансформации ключей списка, через ключи не получится изменить 
name_list = {
    'Alex': '1',
    'Vova': '2',
    'Vasya': '3',
    'John': '4',
    'Igor': '5',
    'Nikita': '6',
}
new_list = {}
for name, value in name_list.items():
    new_list[f"{name}_{value}"] = value

new_list = {f"{name}_{value}": value
            for name, value in name_list.items()}

new_list = dict(map(lambda el: (f"{el[0]}_{el[1]}", el[1]), name_list.items()))

print(new_list)

#教え
Видео 7/22 30:00 -> 50:00

# Итератеры

это механизм помогающий последовательно проходить объектам последовательностям (sequences-str,list,set)

по сути любой объект можно следать итерируемым, если в его содержимом есть что перебирать, для этого нужно
class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

# Пример использования
my_data = MyIterator([1, 2, 3, 4, 5])
for item in my_data:
    print(item)

#value Pytup 2024: итоги года.

Онлайн трансляция новогоднего митапа сообщества python Moscow
https://youtu.be/Wk4rmWrIliM?list=TLGGosPE8qS7T10xOTEyMjAyNA

#value Основные моменты Pytup 2024: итоги года Часть I

## Тренды

### 1) Саб-интерпретаторы в Python

В Python есть такая механика, как GIL (Global Interpreter Lock) — в моменте может работать только один поток обработки Python, доступ к объектам также возможен только из одного потока. Это безопасно, но узко для производительности.

Для решения этой проблемы используются обсуждаемые и экспериментируемые саб-интерпретаторы.

Основные моменты о саб-интерпретаторах:

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

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

- Многопоточность: Саб-интерпретаторы могут обеспечить более эффективное использование памяти и CPU в многопоточных приложениях.

### 2) Статические атрибуты

В контексте Python «статические атрибуты» (или «статические свойства») относятся к атрибутам, которые принадлежат классу, а не его экземплярам. Это означает, что статические атрибуты создаются на уровне класса и могут быть доступны через сам класс, а не через экземпляр.

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

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

#value Основные моменты Pytup 2024: итоги года Часть II

## 3) Обновления в Python 3.13

### Поддержка Android и iOS

В Python платформы распределяются по приоритету поддержки:

1. Основные и наиболее распространенные версии Python и платформы:
Windows, macOS, Linux.

2. Python 2.7, FreeBSD или некоторые дистрибутивы Linux.

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

По сути, в файлах Python устанавливаются папки, соответствующие новым платформам, и там указываются флаги для их обработки. По идее, теперь можно будет запустить Python на Android и iOS по умолчанию, а не через сторонние оболочки (если имеется Python-ядро).

## 4) RAF и линтеры

- RAF (Rapid Application Framework):
Как уже упоминалось, это концепция быстрого создания приложений с использованием фреймворков, которые упрощают процесс разработки.

- Линтеры в контексте Python:
Линтеры — это инструменты статического анализа кода, предназначенные для выявления ошибок, предупреждений и проблем в коде. В Python популярными линтерами являются:

* Pylint — мощный инструмент для проверки качества кода.
* Flake8 — объединяет функциональность PEP 8 (стилистические рекомендации для Python) и других проверок.
* Black — автоформатировщик, который следит за стилем кода.

### Связь между RAF и линтерами

1. Разработка с RAF: Если вы используете Rapid Application Framework для разработки вашего веб-приложения на Python, вы можете интегрировать линтеры в процесс разработки, чтобы соблюсти стиль кода и уменьшить количество ошибок.

2. Развёртывание на VPS: После разработки приложение можно разместить на VPS. Это позволяет вам управлять средой выполнения и более гибко настраивать сервер под ваши нужды.

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

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

## 5) Какие интересные open-source проекты открылись в 2024

- HTTP Client Nikwest: Новый HTTP-клиент как аналог для httpx (эти ребята однажды сломали обратную совместимость, и много кто, как я понял, погорел на этом).

- Интересный язык Glim: Как Go и Rust вместе (к Python не относится).

#教え
Видео 7/22 50:00 -> 1:01:00

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

>>>my_generator = (x*x for x in range(3)) # с помощью comprehension
>>> animals = ['cat', 'dog', 'monkey']
>>> animals
['cat', 'dog', 'monkey']
>>> def animal_generator(): # по классике
...     for animal in animals:
...             yield animal # вместо return
...
>>> animal_gen = animal_generator()
>>> type(animal_gen)
<class 'generator'>
>>> animal_1 = next(animal_gen) # next(вызов следующей выработки, следующего объекта)
>>> animal_1
'cat'
>>> next(animal_gen) 
'dog'
>>> next(animal_gen)
'monkey'
>>> next(animal_gen) # при вызове next для закончившего выработку генератора всплывет ошибка StopIteration
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

#event Changellenge инфа от рекрутеров

При разговоре с рекрутерами показывал резюме.

По резюме стоит расписать конкретнее, чем я занимался.
Если есть цифры, то это отлично — например, "за год работы в компании восстановил и обновил 36 устаревших сервисов".
Указать конкретные рабочие кейсы.

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

На каких ресурсах искать работу:

HR-почта компании — отправлять резюме с сопроводительными письмами. Обычно такие почты можно найти на сайтах компаний, но возможно, придется брать их у разработчиков, уже работающих в них.
Телеграм и ВК компаний.
Каналы и блоги компаний. В них стоит немного поактивничать, полайкать и оставить умные комментарии (возможно, тут можно использовать селф-промо, возможно есть шанс, что тебя тоже где-то заметят).
Блог вакансий компании.
Также рекрутер ФБК говорит, что для неё важно, чтобы кандидат имел представление о конкретном бизнесе:

Читал о компании, её историю.
Знал, чем она занимается.
Знал, какие сервисы предлагает.
Осведомлён о технологиях.

#教え
Видео 7/22 50:00 -> 1:20:00

Скрипты на python
Функции можно вызывать из терминала и передавать аргументы. Например, если нужно одной командой подключиться к vpn.

#Скрипт подсчитывает количество файлов с указанным расширение по пути   
from pathlib import Path
from pprint import pprint
import sys

print(sys.argv)
try:
    print()
    # Создаем объект Path для указанной директории
    path = Path(sys.argv[1])

    file_counter = 0
    files = path.iterdir()
    contents = len(list(filter(lambda x: sys.argv[2] in x.suffix, files)))
    # contents = [(lambda files, file_counter: file_counter += 1)()
    #             for item in]  # Список с именами
    pprint(contents)
except FileNotFoundError:
    print(f"Папка '{sys.argv[1]}' не найдена.")
except Exception as e:
    print(f"Произошла ошибка: {e}")