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

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

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

Болтливый путь:

def обработать_данные(данные):
    if данные is None:
        print("Предупреждение: нет данных для обработки!")
        # Тут код продолжает выполняться или останавливается, но предупреждение было лишним
    else:
        # Нормальная обработка данных
        print("Данные обработаны успешно")

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

Молчаливый, но эффективный путь:

def обработать_данные(данные):
    if данные is None:
        # Молча возвращаем специальное значение или ничего не делаем, если так задумано
        return None
    # Нормальная обработка данных
    print("Данные обработаны успешно")

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

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

#ЗенПитона

Рубрика: #ПервыйКодНаРайоне — так мы даем понять, что эти посты как раз для тех, кто только начинает свой путь в нашем кодерском мире.

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

1. Создание списка:
Сначала ты создаешь свою братву:

   братва = ['Васян', 'Петька', 'Колян']
   

Здесь 'Васян' — это пацан номер один, 'Петька' — номер два, и так далее.

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

   братва.append('Саныч')
   

Теперь Саныч — тоже часть нашей улицы.

3. Удаление элемента:
Если кто-то слишком зазнался и пора ему от нас отдохнуть, ты можешь его выкинуть:

   братва.remove('Колян')
   

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

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

   первый_брат = братва[0]
   

Теперь у тебя есть Васян, и ты можешь с ним порешать дела.

5. Срезы списка:
Если надо собрать нескольких пацанов, можно использовать срез:

   основные_братки = братва[1:3]
   

Теперь у тебя есть Петька и Колян, если он еще с нами.

6. Длина списка:
Чтобы узнать, сколько человек в твоей братве, пользуйся len:

   колво_братвы = len(братва)
   

Понял, сколько нас, понял, на что можешь рассчитывать.

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

   for брат in братва:
       print(брат)
   

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



8. Поиск элемента:
Чтобы проверить, есть ли твой брат в строю, используй in:

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

Это как спросить всех: "Вы видели Саныча?"

9. Получение индекса элемента:
Если тебе нужно знать, под каким номером твой братишка стоит в списке, примени index:

   номер_саныча = братва.index('Саныч')
   

Теперь ты точно знаешь, где твой человек в строю.

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

   брат = 'Саныч'
   if брат in братва:
       номер = братва.index(брат)
       print(f'{брат} на своем месте под номером {номер}.')
   else:
       print(f'{брат} сегодня не с нами.')
   

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

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

Большинство разработчиков никогда не видело модель предметной
области, только модель данных.
Сирил Мартрайр

Когда мы болтаем с разрабами про архитектуру, многие вздыхают и говорят, что могло бы быть и покайфовее. Они хотят спасти свою систему, что уже вязнет в своих же багах и зависимостях, как бардак в комнате после трехдневных тусовок. Все эти ребята знают, что их бизнес-логика должна быть чистой, как девчонка из хорошей семьи, но вот как это сделать — голова кругом.
И вот, начинают клепать новую систему, и первым делом колдуют над схемой базы данных, как будто это самое главное. А потом, когда уже весь проект как бы на ногах стоит, вдруг до них доходит: "А давайте-ка мы еще и объектную модель замутим!" И тут все начинает разваливаться, как картонный домик после дождя, потому что важное было на заднем плане.
Короче говоря, первым делом должно быть то, как система себя ведет, а уже потом под это подгоняем хранилище данных. Наши клиенты, пацаны, не хотят знать, как у нас там все устроено внутри. Им важно, чтобы оно работало, иначе они бы и в Excel сами все сделали.
В первой части мы вам покажем, как собрать объектную модель, используя тестирование, и как отвязать эту красоту от технической мороки. Будем рубить код, не зависящий от базы данных, и строить крепкие API вокруг бизнеса.
И погнали мы вам четыре крутых фишки показать:
- Репозиторий — это как наш тайник, где все данные прячем.
- Сервисный слой — это как правила района, кто, куда и зачем идет.
- UoW (Unit of Work) — чтобы наши движения были согласованными.
- Агрегат — чтобы данные всегда были целы и невредимы.
И если вам интересно, куда мы катим, гляньте на рисунок в начале книги. Не парьтесь, если сразу не поняли, по ходу разберем каждый кирпичик.

Так что, братва, вперед, будем штурмовать эти паттерны и делать наш код чистым, как новенький мерс на районе!


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

Правило: В строчке должен быть кайф.

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

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

Без кайфа:

def calc(x):
    return x + 10 - 5 * 3 / 2

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

С кайфом:

def улучшить_настроение(энергия):
    магическое_число = 10
    улучшение = энергия + магическое_число
    улучшение = улучшение - 5  # немного убавим для баланса
    улучшение *= 3  # утроим улучшение
    улучшение /= 2  # поделим на два для идеального баланса
    return улучшение

# Теперь когда ты вызываешь функцию, ты точно знаешь, что она делает улучшение настроения, а не просто какие-то абстрактные расчеты.

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

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

#ЗенПитона

Правило: Но не настолько, чтобы всюду его искать.

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

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

Искать кайф везде:

def сделать_что_то_крутое(данные):
    # Пытаемся применить каждую известную нам хитрость, чтобы код выглядел "круто"
    return ((данные * 2) ** 0.5 / 2).real + [x for x in range(10) if x < 5][-1]

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

С кайфом, но без фанатизма:

def улучшить_данные(данные):
    # Делаем работу понятно и эффективно, с небольшим изяществом
    базовое_улучшение = данные * 2
    финальное_улучшение = базовое_улучшение + 5
    return финальное_улучшение

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

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

#ЗенПитона

#ПервыйКодНаРайоне
Братва, поговорим о кортеже (tuple) на языке улиц, но через призму передачки, знаете такое дело? Кортеж — это твоя передачка в тюрягу. Раз упаковал — и больше не тронешь, всё по канонам.

1. Запаковка передачки:
Собираешь передачку так:

   передачка = ('сиги', 'конфеты', 'чай')
   

Как запечатал и отдал — так оно и дойдет, без вариантов.

2. Доставка до адресата:
Когда пора достать что-то из передачки:

   что_в_передачке = передачка[0]  # сиги на выходе
   

Первое — всегда сиги, как по понятиям.

3. Передачка не резиновая:
Помни, в передачку новое не добавишь:

   передачка[1] = 'кофе'  # Так не прокатит, братан
   

Попытка замены — и сразу нарушение, не туда.

4. Сколько всего в передачке:
Чтобы знать объем:

   всего_в_передачке = len(передачка)
   

Так узнаешь, сколько всего позиций отослал.

5. Разбивка по полочкам:
Если надо всё по полочкам раскладывать:

   сиги, конфеты, чай = передачка
   

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

6. Проверяем содержимое:
Чтобы никто не обиделся и каждый был учтен:

   for вещь in передачка:
       print(вещь)
   

Пройдешься по всем пунктам — все на месте, чисто.

Короче, кортеж — это твоя четкая передачка, браток. Однажды сделал — и она идет по назначению, без права на переделку. Это как дать слово на зоне: раз сказал, значит так и будет. Используй кортеж, когда надо все держать под контролем и без сюрпризов.
#ПервыйКодНаРайоне

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

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