Братва, давайте всё, что мы тут разбирали, сведем к основам схемы оборота на районе. Это будет наша карта действий, чтобы каждый знал своё место и роль в этой большой игре.

1. Предметная область — это наш район, наша территория. Это может быть всё что угодно: от магазина мебели до автосервиса. Главное, это та сфера, где мы крутимся и знаем каждую закладку.

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

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

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

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

6. Реальная модель предметной области — это наша карта района, которая отражает реальное положение дел. Это позволяет нам видеть всю картину целиком и понимать, как наши действия влияют на общий результат.

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


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

# Сущности - это как главные братки на районе, только здесь это лекарства
class Лекарство:
    def __init__(self, название, категория):
        self.название = название
        self.категория = категория

# Объекты-значения - это вещи, важные, но не критичные, например, адрес аптеки
class Адрес:
    def __init__(self, улица, номер_дома, город):
        self.улица = улица
        self.номер_дома = номер_дома
        self.город = город

# Служба предметной области - это наши услуги на районе, например, доставка лекарств
class СлужбаДоставки:
    @staticmethod
    def доставить(адрес):
        print(f"Доставляем лекарство по адресу: {адрес.улица}, {адрес.номер_дома}, {адрес.город}")

# Пример использования
парацетамол = Лекарство("Парацетамол", "Жаропонижающее")
адрес_доставки = Адрес("Пушкина", 15, "Санкт-Петербург")
СлужбаДоставки.доставить(адрес_доставки)

В этом коде мы смоделировали типичную операцию для аптеки: имеем лекарство Парацетамол, которое нужно доставить по определенному адресу. Сущность Лекарство отражает ключевой продукт нашего бизнеса. Адрес остается объектом-значением, важным для операции доставки, но не являющимся центром всей системы. И СлужбаДоставки выполняет свою роль, обеспечивая доставку лекарств до клиента.

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

#паттерны #фишки #схемы

Правило: Лучше один раз увидеть, чем сто раз услышать.

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

В мире кода это выглядит так:

Словами:

# Здесь мы описываем, как работает наша функция, используя комментарии
# Эта функция принимает список чисел и возвращает их сумму
def сумма_чисел(список_чисел):
    # Итерируем по списку, суммируя элементы
    сумма = 0
    for число in список_чисел:
        сумма += число
    return сумма
# Пока не запустишь, не увидишь, как она работает на практике.

На деле:

def сумма_чисел(список_чисел):
    return sum(список_чисел)

# Демонстрация работы функции
пример_списка = [1, 2, 3, 4, 5]
print(f"Сумма чисел {пример_списка} равна {сумма_чисел(пример_списка)}")

Здесь мы не только объяснили, что делает функция, но и показали ее работу на конкретном примере. Это сразу дает понять, как функция работает и каков будет результат ее работы.

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

#ЗенПитона

#ПервыйКодНаРайоне
Братва, давайте ка разберемся с set (множеством), но на языке закупок для нашего районного праздника. Множество в Python — это как список покупок, который сам по себе не допускает повторяшек. Ты можешь сколько угодно раз пытаться вписать в него "пиво", но в итоговом списке оно будет только один раз. Вот как это работает на улицах:

1. Создание списка покупок:
Записываем, что нам надо закупить, без повторов:

   закупка = set(['пиво', 'чипсы', 'семки', 'пиво'])
   

Мы два раза "пиво" вписали, но оно учтется один раз, потому что множество — не терпит двойников.

2. Добавление в список:
Если вспомнили, что забыли водку, легко добавляем:

   закупка.add('водка')
   

Теперь в списке покупок есть и водка, но все равно каждый товар — по одному разу.

3. Удаление из списка:
Если решили, что семки — это лишнее:

   закупка.discard('семки')
   

И вот семок уже нет, список покупок чище.

4. Проверка наличия:
Чтобы не забыть про колу, проверяем:

   if 'кола' in закупка:
       print('Кола уже в списке.')
   else:
       закупка.add('кола')
   

Так ты убедишься, что кола не забыта.

5. Проход по списку:
Перед выходом проверяем, все ли взяли:

   for товар in закупка:
       print(товар)
   

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

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

6. То, что надо закупить:
Сначала мы составили список того, что нам нужно для тусы:

   закупка = set(['пиво', 'чипсы', 'водка', 'кола'])
   

7. То, что уже есть на складе:
Потом мы чекнули, что у нас уже есть на складе:

   склад = set(['семки', 'пиво', 'кола'])
   

8. То, что обещали как подгон:
И нам еще обещали подкинуть некоторые вещи:

   подгон = set(['водка', 'сок', 'пиво'])
   

9. Что уже не надо закупать:
Теперь давайте выясним, что нам уже не надо закупать, потому что это либо уже на складе, либо обещали как подгон. Смотрим на пересечения множеств:

   уже_есть = склад.intersection(закупка).union(подгон.intersection(закупка))
   

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

10. Что осталось закупить:
Наконец, вычитаем из нашей первоначальной закупки то, что уже есть или обещано, чтобы понять, что еще надо купить:

   осталось_закупить = закупка - уже_есть
   

Теперь мы точно знаем, что осталось закупить, чтобы не тащить лишнее.

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

#ПервыйКодНаРайоне

Правило: Если реализация трудно объяснить – идея фигня.

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

В мире кода это выглядит так:

Сложно объяснимая реализация:

def выполнить_задачу(данные):
    # Здесь какой-то очень сложный и запутанный код, который использует несколько вложенных циклов,
    # неочевидные условия и трюки с данными, которые трудно отследить и понять с первого взгляда.
    pass

Если попытаться объяснить, как это работает, вероятно, займет много времени и слов, и все равно останутся вопросы.

Просто объяснимая реализация:

def сортировать_список(список):
    # Используем встроенную функцию Python для сортировки списка.
    # Это просто, понятно и легко объяснимо.
    return sorted(список)

# Простое объяснение: "Функция принимает список и возвращает его отсортированным."

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

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

#ЗенПитона

Окей, братва в рубрике #ПервыйКодНаРайоне, сегодня поговорим про словари (dict) в Python. Словарь — это как наша база данных на районе: знает всех по именам и фамилиям, кто чем занимается, кто где живет. В общем, когда надо что-то быстро найти или узнать, к кому бежать, словарь — твой лучший друг. Вот как это работает:

1. Создание словаря:
Сначала ты создаешь свой словарь, это как записная книжка:

   братва = {'Васян': 'тайник с деньгами', 
             'Петька': 'ключи от гаража', 
             'Колян': 'адрес склада'}
   

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

2. Добавление в словарь:
Если вдруг в районе появляется новый братишка, легко добавляем его:

   братва['Саныч'] = 'пароль от сейфа'
   

Саныч теперь тоже в деле.

3. Удаление из словаря:
Если кто-то слинял или перестал быть нашим, без проблем вычеркиваем:

   del братва['Колян']
   

Колян больше не с нами.

4. Доступ к элементу:
Когда надо что-то узнать, просто спрашиваем у словаря:

   задача_васяна = братва['Васян']
   

И ты точно знаешь, что у Васяна в зоне ответственности.

5. Проверка наличия:
Прежде чем идти к брату, удостоверься, что он есть в списке:

   if 'Саныч' in братва:
       print('Саныч с нами!')
   

Это как проверить, не слинял ли кто на тихаря.

6. Проход по всем элементам:
Иногда надо сверить, все ли на месте и ничего не забыли:

   for имя, задача in братва.items():
       print(f'{имя} занимается {задача}')
   

Так ты пройдешься по всем и каждому, и убедишься, что порядок.

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

#ПервыйКодНаРайоне

Правило:

"Если реализацию легко объяснить – идея может быть кайфовой."

В мире воровайки, когда приходит новенький, ему надо понять основы. Вот ты ему говоришь: "Слышь, брат, тут всё просто. Когда ты крадешь кошелек, главное — не заметно. Ты его берешь и спокойно уходишь. Всё." Если новичок сразу улавливает суть, значит, план годный и простой, его легко выполнять и легко учиться на его основе.

То же самое в коде. Когда ты можешь в двух словах объяснить, что делает твоя программа или функция, это значит, ты нашел четкое и красивое решение. Пример с отчислениями в общак? Ты говоришь: "Берем всю кассу, вычитаем расходы, часть отдаем в общак. Что осталось — наше." Все понятно, никаких заморочек.


Айда, давайте пример кода на Python, который иллюстрирует эту идею: просто и понятно рассчитываем долю для общака и чистую прибыль. Это как воровской оборот, но чисто в коде.

def рассчитать_долю_для_общака(касса, расходы, процент_в_общак):
    чистая_прибыль = касса - расходы
    доля_в_общак = чистая_прибыль * процент_в_общак / 100
    наши_деньги = чистая_прибыль - доля_в_общак
    return наши_деньги, доля_в_общак

# Использование функции
касса = 1000000  # Всего заработали
расходы = 30000  # Расходы на закупку и прочее
процент_в_общак = 10  # Сколько процентов отдаем в общак

наши_деньги, доля_в_общак = рассчитать_долю_для_общака(касса, расходы, процент_в_общак)
print(f"Наши деньги после всех отчислений: {наши_деньги}, Доля в общак: {доля_в_общак}")

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

Это пример, как можно в паре строк объяснить даже новичку, что делает код: "Берем всю кассу, вычитаем расходы, часть отдаем в общак. Что осталось — наше." Никаких сложностей и лишних заморочек. Такой код легко читается, легко поддерживается и легко изменяется, если условия игры меняются.

Это правило важно для воровского хода, потому что:
- Чем проще план, тем меньше шансов наломать дров. В сложном плане можно запутаться, забыть что-то важное или не учесть риск. В простом плане все на виду.
- Новичкам легче вливаться в дело. Когда ты можешь просто и ясно объяснить, как работает ваша схема, новые братья быстрее становятся частью команды. Они точно знают, что от них требуется, и как вести себя в разных ситуациях.
- Легче находить и исправлять ошибки. В сложной схеме трудно понять, где ты налажал, если что-то пошло не так. В простой — сразу видно, где проблема.

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

#ЗенПитона

В тему #ПервыйКодНаРайоне рассмотрим декораторы в Python, но на этот раз через призму нашего воровского дела, когда на улицах разное количество мусоров. Суть в том, как декоратор помогает нам адаптировать нашу тактику продажи шаурмы, учитывая, что уровень осторожности зависит от количества мусоров на улице, и изменяется он не прямо, а логарифмически.

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

import math

def подстройка_под_мусоров(функция):
    def обертка(мусоров_на_улице):
        уровень_осторожности = math.log(мусоров_на_улице + 1)  # +1, чтобы избежать log(0)
        print(f"Уровень осторожности: {уровень_осторожности:.2f}")
        if уровень_осторожности < 2:
            print("Мусоров почти нет, работаем как обычно.")
        elif уровень_осторожности < 3:
            print("Немного напрягаемся, но продолжаем работу.")
        else:
            print("Осторожно, мусоров много, продажи на минимуме.")
        функция(мусоров_на_улице)
    return обертка

@подстройка_под_мусоров
def продажа_шаурмы(мусоров_на_улице):
    print("Продажа шаурмы идет...")

# Ситуация на улице меняется
продажа_шаурмы(1)  # Мало мусоров
продажа_шаурмы(5)  # Среднее количество мусоров
продажа_шаурмы(15) # Много мусоров

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

Это пример того, как декораторы помогают нам быть гибкими и адаптироваться к изменениям, не меняя основной код действия. Он добавляет дополнительный слой логики, который позволяет нашей программе (или нашему бизнесу на районе) реагировать на разные условия внешней среды. Так мы всегда остаемся на волне и можем максимально эффективно вести свои дела, несмотря на присутствие мусоров.

С таким же успехом мы можем применить этот декоратор на остальные продажи.
#ПервыйКодНаРайоне

#ЗенПитона #ПервыйКодНаРайоне
Привет, братва! Сегодня раскрываем один из крутых принципов зен Питона –

Пространства имен это отличная штука, давайте делать их больше!

Но что это значит на районном языке?

Представь ситуацию: у нас в банде два парня, оба с именем Серега, но один – мастер на все руки, а другой – красноречивый разговорчивый парень. Чтобы не путаться, когда мы говорим о ком-то из них, мы называем одного Серега-Мастер, а другого – Серега-Разговорчивый.

Вот как это выглядит в коде:

# Представим, что у нас есть два файла: master.py и talkative.py
# В master.py у нас:
class Серега:
    def навыки(self):
        return "ремонт, стройка, вождение"

# В talkative.py у нас:
class Серега:
    def навыки(self):
        return "убеждать, торговать, вести переговоры"

# Теперь импортируем наших Серег под разными псевдонимами
from master import Серега as СерегаМастер
from talkative import Серега as СерегаРазговорчивый

# И используем их в коде
мастер = СерегаМастер()
разговорчивый = СерегаРазговорчивый()

print("Серега-Мастер умеет:", мастер.навыки())  # Серега-Мастер умеет: ремонт, стройка, вождение
print("Серега-Разговорчивый умеет:", разговорчивый.навыки())  # Серега-Разговорчивый умеет: убеждать, торговать, вести переговоры

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

Не забываем: крутой код – это как крутой район, где каждому есть место и каждый знает свои задачи.
#ЗенПитона
#ПервыйКодНаРайоне

Встречаем рубрику #КодБлатногоУровня


Эй, пацаны! Сегодня у нас урок кода, но не сухой и скучный, а наш, районный. Покажем, что singledispatch в питоне классно дополняет декораторы, встречаем наших по коду. У нас тут Чушпан, Пахан и Боец – каждому свое, но уважение далеко не всем.

Вот как это выглядит в коде:

from functools import singledispatch
from abc import ABC, abstractmethod


class Чушпан(ABC):
    pass


class Пахан(ABC):
    pass


class Боец(ABC):
    pass


@singledispatch
def поприветствовать(личность):
    raise NotImplementedError("Из каких будешь, братишка? Не, не, не - проходи!")


@поприветствовать.register(Чушпан)
def _(личность):
    return f"Чушпан {личность.кликуха} вали, пока не дали!"


@поприветствовать.register(Пахан)
def _(личность):
    return f"Пахан {личность.кликуха} в деле!"


@поприветствовать.register(Боец)
def _(личность):
    return f"Боец {личность.кликуха} готов к бою!"


# Примеры личностей
class Вася(Чушпан):
    кликуха = "Подзаборный"


class Петя(Пахан):
    кликуха = "Суровый"


class Коля(Боец):
    кликуха = "Бык"


# Пример использования
print(поприветствовать(Вася()))  # Чушпан Подзаборный вали, пока не дали!
print(поприветствовать(Петя()))  # Пахан Суровый в деле!
print(поприветствовать(Коля()))  # Боец Бык готов к бою!

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

Не забываем: кодинг – это не просто писанина, это часть нашей жизни. #КодБлатногоУровня

#ПервыйКодНаРайоне
В Python со строками можно делать всякие штуки, как на районе с тегами: красить, перекрашивать, добавлять что-то свое. Только в коде это выглядит как функции работы с текстом. Вот несколько примеров:

1. Длина строки:
Как узнать, сколько в твоем слогане символов? Это как считать деньги после дня работы.

текст = "Мой район лучший"
print(len(текст))  # покажет, сколько символов в строке

2. Нахождение подстроки:
Это как когда ты ищешь брата по кличке на большой площади.

if "район" in текст:
    print("Слово 'район' есть в тексте")

3. Замена в строке:
Меняем одно на другое, как старые кроссы на новые.

новый_текст = текст.replace("лучший", "самый крутой")
print(новый_текст)  # "Мой район самый крутой"

4. Разбиение и соединение:
Это как разбить банду на малые группы и потом снова собрать всех вместе.

слова = текст.split(' ')  # Разбиваем на слова
print(слова)  # ['Мой', 'район', 'лучший']
воссоединенный_текст = " ".join(слова)  # Соединяем обратно
print(воссоединенный_текст)  # "Мой район лучший"

5. Преобразование регистра:
Это как менять голос, чтобы звучать серьезнее или наоборот, дружелюбнее.

крик = текст.upper()  # "МОЙ РАЙОН ЛУЧШИЙ"
шепот = текст.lower()  # "мой район лучший"
каждое_слово_с_большой = текст.title()  # "Мой Район Лучший"

6. Удаление пробелов:
Как выкидывать мусор из карманов перед домом.

мусорный_текст = "    Мой район    "
очищенный_текст = мусорный_текст.strip()  # уберет все пробелы по краям
print(очищенный_текст)  # "Мой район"

7. Начинается или заканчивается:
Как проверить, все ли в порядке с тегом на стене.

if текст.startswith("Мой"):
    print("Текст начинается с 'Мой'")
if текст.endswith("лучший"):
    print("Текст заканчивается на 'лучший'")

Эти функции – это базовый инструментарий для работы с текстом в Python. Это как иметь хороший набор инструментов в гараже: всегда найдется то, что нужно для работы. Умея их использовать, ты сможешь легко манипулировать текстами в своих программах, будь то чтение данных, форматирование сообщений или что-то еще, связанное со словами и предложениями.

Так что, братва, не забывайте: в коде, как и на улице, важно уметь работать с информацией – и текст тут не исключение. Учитесь, экспериментируйте и держите ухо востро! #ПервыйКодНаРайоне

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

1. Попадание в неприятности (`try`): начинаешь день, не знаешь, что тебя ждет.

   try:
       # пробуем что-то сделать
   

2. Столкновение с неожиданностью (`except`): на улице встретился с ментом (PermissionError), соперником (ConflictError) или нечто странным (UnexpectedError).

   except PermissionError:
       # обработка случая с ментом
   except ConflictError:
       # действия, если встретил соперника
   except UnexpectedError:
       # если случилось что-то неожиданное
   

3. Проверка условий (`assert`): как проверить, закрыл ли ты дверь перед выходом.

   assert условие, "Сообщение об ошибке"
   

4. Вызов исключения (`raise`): если что-то идет не так, как планировал, ты кидаешь вызов.

   raise TypeError("Что-то пошло не так")
   

5. Все прошло гладко? (`else`): если обошлось без проблем, идешь дальше.

   else:
       # все чисто, идем дальше
   

6. Подведение итогов (`finally`): в конце дня, несмотря на все, ты возвращаешься домой.

   finally:
       # заканчиваем день
   

Помните, парни, как в жизни, так и в коде: нужно быть готовым к любым ситуациям, уметь стоять за себя и знать, когда действовать по плану, а когда - выходить из положения. #ПервыйКодНаРайоне

#ПервыйКодНаРайоне #фишки
Ребята, сегодня поговорим о трех вещах, которые каждый кодер на Python должен знать – это pip, poetry и виртуальное окружение. Это как основные инструменты в вашем районе, которые помогут держать дела под контролем.

PIP

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

Poetry

Если PIP – это торговец, то Poetry – это ваш личный бухгалтер и организатор. Он не только умеет делать всё то же, что и PIP, но и следит за тем, чтобы все ваши инструменты (зависимости) были аккуратно уложены, не конфликтовали друг с другом и легко обновлялись. Это как если бы у вас был помощник, который не только следит за вашим инвентарем, но и убеждается, что все ваши инструменты в хорошем состоянии и готовы к работе.

Виртуальное окружение

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

Вместе эти инструменты создают сильную команду для любого разработчика. Используя PIP, вы можете получить все, что вам нужно. С Poetry вы упорядочите все ваши инструменты и материалы. А виртуальное окружение позволит вам работать над разными проектами одновременно, не создавая хаоса. Это как иметь в своем распоряжении весь район, где каждый знает свое дело и все работает как часы.

И вот что: мы только затронули поверхность. Далее мы раскроем эти темы поподробнее. Будем копать глубже, чтобы вы поняли каждый уголок PIP, каждую хитрость Poetry и каждый секрет виртуального окружения. Как профессионалы района, мы не оставим камня на камне, пока не разберемся в каждой детали. Готовьтесь, будет интересно!
#ПервыйКодНаРайоне #фишки

#ПервыйКодНаРайоне #фишки #pip

PIP - часть 1

Общие параметры:
- -v или --verbose: Как кричать на весь район, когда что-то делаешь. Показывает больше инфы.
- -q или --quiet: Наоборот, молчишь, как партизан. Меньше вывода информации.
- -h или --help: Как спросить старших братьев, когда в затруднении. Показывает, что и как можно делать.
- -V или --version: Чтобы проверить свои "часы" - версию PIP.
- --isolated: Игнорирует настройки окружения, как забить на все и делать свое.
- --log PATH: Записывает, что происходит, в лог-файл, как дневник событий района.
- --proxy USER:PSWD@SERVER:PORT: Если надо через прокси, то это как пойти через дворы.
- --retries X: Сколько раз пытаться связаться, если что-то не так.
- --timeout SECONDS: Сколько секунд ждать перед попыткой снова.
- --cache-dir DIR: Куда складывать кэш, как свой секретный тайник.
- --no-cache-dir: Не использовать кэш, каждый раз все новое.
- --disable-pip-version-check: Не проверять версию PIP, как игнорировать слухи.
- --cert PATH: Путь к сертификату, если нужно подтверждение.
- --client-cert CERT: Твой личный сертификат, когда нужно доказать, что ты свой.
- --trusted-host HOSTNAME: Как доверенное лицо в районе, сервер, которому веришь.


Список пакетов (pip list):
Как проверить, что у тебя в рюкзаке, так и pip list покажет все, что установлено в твоем Python-мире.

- -o или --outdated: Показывает устаревшие пакеты, как старые кеды, что пора менять.
- -u или --uptodate: Список актуальных пакетов, все в норме, как новые кроссы.
- -e или --editable: Показывает пакеты, установленные в редактируемом режиме, как твой кастомизированный байк.
- -l или --local: Показывает пакеты установленные в локальной виртуальной среде, как твои штуки в твоем дворе.
- --user: Показывает пакеты установленные только для твоего пользователя, как личные вещи в твоем закрытом шкафу.
- --pre: Включает в список предварительные и экспериментальные версии, как пробные версии новых гаджетов.

Поиск пакетов (pip search):
Когда ищешь что-то новенькое, как новые треки или кроссовки:
- pip search ключевое_слово: Находишь пакеты по ключевым словам, как искать в интернете инфу.

Инфо о пакетах (pip show):
Как спросить у брата всю инфу о новой игре:
- pip show имя_пакета: Дает тебе всю инфу о пакете, от версии до зависимостей.
- -f или --files: Показывает все файлы, связанные с пакетом, как список вещей в новом китайском гаджете.

Удаление пакетов:
- `pip uninstall имя_пакета`: Как выкинуть ненужное из вашей квартиры.
- `-r FILE`, `--requirement FILE`: Если надо удалить кучу штук, указанных в файле, как список ненужных вещей.
- `-y`, `--yes`: Просто делает все без вопросов, как когда ты уверен в своем деле.

Заморозка зависимостей:
- `pip freeze`: Создает список всех ваших зависимостей, как запись ваших долгов.
- `-r FILE`, `--requirement FILE`: Использует порядок, указанный в файле, для вашего списка.
- `-f URL`, `--find-links URL`: Где искать пакеты, если они не в обычном месте.
- `-l`, `--local`: Показывает только пакеты, установленные в вашем локальном окружении.
- `--user`: Показывает пакеты, установленные только для вашего пользователя.

Установка пакетов:
- `pip install имя_пакета`: Как купить новые вещи для дома.
- `-r FILE`, `--requirement FILE`: Установить все из списка, как закупка по списку.
- `-b DIR`, `--build DIR`: Где строить (собирать) пакеты.
- `-t DIR`, `--target DIR`: Куда ставить пакеты, как выбрать место в доме.
- `-d DIR`, `--download DIR`: Только скачать, не устанавливать, как сохранить для потомков.
- `-U`, `--upgrade`: Обновить указанные пакеты.
- `--force-reinstall`: Переустановить пакеты при обновлении.
#ПервыйКодНаРайоне #фишки #pip

#ПервыйКодНаРайоне #фишки #pip
Продвинутая установка пакетов:

Когда устанавливаешь пакеты, дело не только в базовых шагах:

- Установка конкретной версии: Это как если бы тебе нужны кроссы определенной модели, чтобы всё было стабильно.

  pip install 'package_name==1.0'
  

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

  pip install 'package_name>=1.0'
  

- Файлы требований: Когда речь идет о куче зависимостей, лучше всё это держать в одном списке, чтобы не запутаться.

  pip install -r requirements.txt
  

- Сборка пакетов: Иногда нужно собрать штуку с нуля, а не использовать готовое.

  pip install --build DIR package_name
  

- Целевая директория: Когда ставишь пакеты в конкретное место, а не туда, куда Python хочет по умолчанию.

  pip install --target=DIR package_name
  

- Без зависимостей: Ставишь пакет без его друзей (делай так только если точно знаешь, зачем это).

  pip install --no-deps package_name
  

- Управление кэшем: Управляй своим кэшем, чтобы сэкономить место и ускорить установку.

  pip install --cache-dir=DIR package_name
  pip install --no-cache-dir package_name
  

Управление зависимостями и обновления:

Когда твоя команда работает над проектом, важно держать все под контролем:

- Обновление пакетов: То же, что обновить свою колонку или телефон до последней модели. Просто говоришь:

  pip install --upgrade имя_пакета
  

Это как переобуться в новые кроссы, чтобы идти в ногу со временем.

- Фиксация зависимостей: Записываешь все, что у тебя есть, чтобы в другой раз не гадать, как это все собиралось.

  pip freeze > requirements.txt
  

Это как сделать четкий список того, что у тебя в гараже.

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

  pip install -r requirements.txt
  

Это как когда у тебя есть список для закупки продуктов на неделю.

- Поиск пакетов: Если ищешь что-то новое или нужно найти альтернативу, используй поиск:

  pip search ключевое_слово
  

Продвинутое управление пакетами:

В этой части мы бы говорили о более сложных вещах, связанных с PIP:

- Управление кэшем: PIP сохраняет копии каждого загруженного пакета. Это как когда ты копишь запчасти для будущих дел – можешь использовать их позже без лишней возни.

  pip cache dir  # показать, где лежит кэш
  pip cache list  # показать все скачанные пакеты
  pip cache purge  # удалить все кэшированные пакеты
  

- Проверка пакетов на соответствие: Это как проверить, все ли твои друзья на месте и в порядке. Убедись, что твои зависимости не конфликтуют и все они безопасны.

  pip check
  

- Использование различных источников для установки: Можешь устанавливать пакеты не только с PyPI. Это как покупать не только в одном магазине, а ещё и у проверенных друзей.

  pip install --index-url другой_источник имя_пакета
  

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

  pip install --extra-index-url приватный_источник имя_пакета
  

#ПервыйКодНаРайоне #фишки #pip

Рубрика #АМужикиТоИНеЗнали на нашем канале демонстрирует необычные и малоизвестные факты о программировании на Python, которые могут удивить даже опытных разработчиков. Это короткие, но мощные порции знаний для тех, кто хочет глубже погрузиться в мир IT и расширить свои горизонты.

Начнём.

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

Контекстные менеджеры в Python используются для обеспечения предварительной и последующей обработки при выполнении блока кода, часто применяются для управления ресурсами. Самый известный пример использования — конструкция with open(...) as ...:, которая гарантирует закрытие файла после выхода из блока with.

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

Вот пример создания простого контекстного менеджера, который записывает в лог начало и конец выполнения какого-либо действия:

from contextlib import contextmanager
import time

@contextmanager
def log_block(name):
    start_time = time.time()
    print(f"Начало выполнения блока '{name}'")
    try:
        yield  # Передать управление в блок with
    finally:
        end_time = time.time()
        print(f"Завершение выполнения блока '{name}'. Время выполнения: {end_time - start_time:.2f} секунд.")

# Пример использования:
with log_block("обработка данных"):
    # Здесь размещается код, который вы хотите выполнить
    # Например, какая-то тяжелая задача
    time.sleep(2)  # Имитация долгой операции

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

#АМужикиТоИНеЗнали

#ПервыйКодНаРайоне #фишки #pip
Ребята, давайте разжуем каждый шаг по созданию и публикации вашего пакета в PIP с примерами и кодом.

Шаг 1: Придумай свой проект
Скажем, у тебя есть полезная функция для вычисления дней до Нового Года. Создай папку newyear_countdown и внутри нее файл countdown.py:

# countdown.py
from datetime import datetime, date

def days_until_newyear():
    today = date.today()
    newyear = date(today.year + 1, 1, 1)
    delta = newyear - today
    return delta.days

Шаг 2: Организуй свой код
Убедись, что структура твоего проекта выглядит так:

newyear_countdown/
    __init__.py
    countdown.py

В __init__.py можно добавить следующее:

from .countdown import days_until_newyear

Шаг 3: Напиши setup.py
В корне твоего проекта (newyear_countdown/) создай файл setup.py:

from setuptools import setup, find_packages

setup(
    name='newyear_countdown', # имя твоего пакета, как ты зовешь свой проект
    version='0.1', # версия твоего пакета, чтобы все знали, насколько он свежий
    packages=find_packages(), # автоматически находит все пакеты (папки с __init__.py), которые нужно включить
    description='Countdown to New Year', # краткое описание твоего проекта, что он делает
    install_requires=[], # список зависимостей, других пакетов, без которых твой не будет работать
)

- name: Это имя твоего пакета. Как ты его зовешь, так он и будет отображаться в PyPI и при установке через pip.

- version: Версия твоего пакета. Важно обновлять ее с каждым значимым обновлением твоего проекта. Следуй принципам семантического версионирования (например, 1.0.0, 1.0.1 для патчей, 1.1.0 для минорных изменений).

- packages: Сюда входят все Python пакеты (каталоги с файлом __init__.py), которые должны быть включены в дистрибутив. find_packages() автоматически находит все такие пакеты в твоем проекте.

- description: Краткое описание того, что делает твой пакет. Это то, что люди увидят в PyPI, когда найдут твой пакет.

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

Это типа твоей личной карточки. Как когда ты приходишь на новую площадку, ты говоришь: "Эй, я такой-то, вот мои фишки, вот что я умею". Так вот, setup.py – это твоя карточка для Python сообщества.

Шаг 4: Протестируй свой пакет
В терминале, в корне проекта, запускай:

python setup.py install

Убедись, что все работает, создав виртуальное окружение и установив туда пакет.

Шаг 5: Зарегистрируйся на PyPI
Перейди на [PyPI](https://pypi.org/) и зарегистрируй аккаунт.

Шаг 6: Собери свой пакет
В корне проекта запускай:

python setup.py sdist

Это создаст файл .tar.gz в папке dist/.

Шаг 7: Загрузи свой пакет
Сначала установи twine:

pip install twine

Затем загрузи пакет:

twine upload dist/*

Тебе нужно будет ввести имя пользователя и пароль от PyPI.

Шаг 8: Поздравляю, ты в игре!
Теперь твой пакет доступен для всех через PIP:

pip install newyear_countdown

Вот так, ребята, шаг за шагом вы превращаетесь из уличных хулиганов в настоящих кодерских крестных отцов. Творите, пацаны, и пусть весь мир узнает о ваших талантах!
#ПервыйКодНаРайоне #фишки #pip

#АМужикиТоИНеЗнали
Давайте рассмотрим пример использования распаковки списков с помощью звездочки * на понятном и простом примере.

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

Вот ваш текущий список друзей:

друзья_с_района = ["Вася", "Петя", "Коля"]

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

новые_друзья = ["Лена", "Оля", "Саша"]

Чтобы объединить эти два списка в один, вы можете использовать распаковку с помощью *, как показано ниже:

все_друзья = [*друзья_с_района, *новые_друзья]

В результате получится следующий список:

["Вася", "Петя", "Коля", "Лена", "Оля", "Саша"]

Это очень удобный способ объединения списков без необходимости использовать циклы или дополнительные методы. Таким образом, вы можете легко собрать всех друзей вместе.
#АМужикиТоИНеЗнали

#АМужикиТоИНеЗнали
Давайте рассмотрим пример использования блока else с циклами в Python на понятном примере.

Представьте, что вы и ваши друзья с района решили сыграть в игру на удачу. Вы кидаете кубик (шестигранный), и если кто-то из вас выбросит шестерку, то этот человек выигрывает и игра заканчивается. Если же никто не выбросит шестерку после нескольких попыток, то все проиграли и решаете попробовать снова позже.

В коде на Python это можно реализовать так:

from random import randint

попытки = 5  # Допустим, у вас есть 5 попыток
for _ in range(попытки):
    бросок = randint(1, 6)  # Кидаем кубик
    print(f"Бросок: {бросок}")
    if бросок == 6:
        print("Выигрыш! Кто-то выбросил шестерку!")
        break
else:  # Этот блок выполнится, если цикл завершился нормально, без 'break'
    print("Проигрыш. Никто не выбросил шестерку. Попробуем в другой раз.")

В этом примере, блок else срабатывает только если цикл for завершился полностью, без прерывания через break. То есть, если никто не выбросил шестерку после всех попыток, выведется сообщение о проигрыше. Если же кто-то выбросил шестерку (и цикл был прерван командой break), блок else не выполняется, и выводится сообщение о выигрыше.

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

#АМужикиТоИНеЗнали

#ПервыйКодНаРайоне
Пацаны, вот коротко о том, чем круты виртуальные окружения в Python, как они работают и зачем вам это нужно.

Виртуальное окружение: закрытая тусовка для твоего кода

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

Создаем окружение:

python -m venv название_для_тусовки

Так ты говоришь Python: "Создай мне место, где я буду шеф".
Общепринятно, и мы рекомендуем использовать названия типа venv или env

Заходим на тусовку (активируем окружение):
- На Unix или macOS:

  source <название_для_тусовки>/bin/activate
  

- На Windows:

  <название_для_тусовки>\Scripts\activate
  

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

Покидаем тусовку (деактивируем окружение):

deactivate

Ты вернулся в реальный мир, где всё как было.

Что тут круто:

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

Наследование от глобального окружения

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

Изоляция ресурсов

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

Оптимизация работы с помощью .pth файлов

Допустим, у тебя есть две тусовки: одна – это твой основной проект, а вторая – это такой сайд-проект, где ты экспериментируешь с новыми фишками. Оба проекта используют некие общие файлы, скажем, твои крутые утилиты, которые ты сам написал и хочешь использовать в обоих местах. Эти утилиты лежат в какой-то отдельной папке на твоем компе, скажем
D:\МоиУтилиты

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

Создай файл с расширением .pth, скажем мои_утилиты.pth, и положи его в папку site-packages, которая находится в твоем виртуальном окружении (это как VIP-зона каждой из твоих тусовок). В этом файле просто укажи путь к папке с твоими утилитами

D:\МоиУтилиты

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

Виртуальные окружения и интерпретаторы Python

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

Так что, ребята, виртуальные окружения – это не просто круто, это ваш инструмент для порядка, безопасности и свободы в мире кодинга. Пользуйтесь на здоровье!
#ПервыйКодНаРайоне