Немного питоновской магии в ленту 🧙‍♂️

>>> d = {1: "раз", 1.0: "два", True: "три"}
>>> d
{1: "три"}

На входе словарь на три разных ключа и значения, на выходе всего одна пара ключ-значение в словаре. Да ещё и значение третье, а ключ первый. Магия, никак не иначе.
Через сутки раскрою секрет волшебства. У кого есть свои версии фокуса, welcome to comments. 🤗

Пришло время раскрыть тайну. Магический секрет словаря кроется в следующем.

1. Ничего не происходит мгновенно. Python читает код слева направо. В этом конкретном случае ключи и значения попадают в словарь по очереди, раз, два, три.

2. При добавлении новой пары key-value вычисляется хэш ключа. Он же индекс для хранения пары. Если в ячейке пусто, добавляем новую пару в словарь. А если ячейка занята, обновляем только значение для существующего ключа. Логично же экономить время и не обновлять ранее добавленный ключ.

3. А теперь магия

>>> hash(1)
1
>>> hash(1.0)
1
>>> hash(True)
1
>>> 1 == 1.0 == True
True



Для Python все три значения одинаковы по значению и по хэшу.
Впрочем, это три совершенно разных объекта в памяти. Но это уже другая история 🤓

P.S. Не путайте хэш и кэш, pls. 🙏

А давайте поговорим про однострочники.

Что это за зверь диковинный? Это попытка решить задачу в одну строку зачастую пренебрегая читаемостью, отлаживаемостью кода.
Конечно же есть хорошие однострочники, Python Style one love 💕 Например обмен переменных местами, генераторные выражения или списковые включения, они же listcomp:

a, b = b, a
gen = (i for i in range(x, y, z) if i not in data)
lst = [*range(n)]

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

А теперь сделаем вид, что у нас соревнования однострочников. 🤓 И необходимо написать FizzBuzz. Если не слышали, то это одна из задач с собеседований. Вывести числа от 1 до 100. Если число кратно 3, то вместо него вывести Fizz. Если кратно 5 - Buzz. А если одновременно кратно 3 и 5, то FizzBuzz.
Ловите Python решение в одну строку ниже. И удачных вам собеседований. 😉

print(*('FizzBuzz' if i % 3 == 0 and i % 5 == 0 else 'Fizz' if i % 3 == 0 else 'Buzz' if i % 5 == 0 else i for i in range(1, 100 + 1)))

А вот вам xyz оператор моржовый := 😱

Морж появился в Python относительно недавно. И многим он совсем не зашёл, в т.ч. и мне. 😏
Решил дать ему второй шанс. И морж практически провалил его. Но... 🦭

Единственная ситуация, где пара := оказалась удобной в использовании - замена бесконечного цикла while True и логической проверки выхода через break.

Было:

while True:
    res = input()
    if res == EXIT:
        break
    ...

Стало:

while (res := input()) != EXIT:
    ...

А в качестве бонуса держите игру в камень, ножницы, бумага против компьютера с моржовым оператором и секретной фишкой внутри 😉

from random import choice

DATA = ('победа', 'поражение', 'ничья',)
CHOICE = {'камень': 'камень', 'ножницы': 'ножницы', 'бумага': 'бумага', 'к': 'камень', 'н': 'ножницы', 'б': 'бумага', 'k': 'камень', 'n': 'ножницы', 'b': 'бумага', 'rock': 'камень', 'scissors': 'ножницы', 'paper': 'бумага', 'r': 'камень', 's': 'ножницы', 'p': 'бумага',}

print(f'Введи полный или короткий вариант из списка: {", ".join(key for key in CHOICE)}')
while (res := input('Что выбрал? ').lower()) in CHOICE:
    print(f'Результат игры для выбора "{CHOICE[res]}": <<<{choice(DATA)}>>>')
else:
    print('Exit game')

P.S. Про "секретную фишку" ровно через сутки на этом же месте. 🤫

Итак, в чём секрет игры в камень, ножницы, бумага. Точнее не самой игры, а её реализации.

Начнём с теории вероятностей. 2 игрока выбрасывают 1 из 3 возможных вариантов. Получаем девять различных комбинаций:
К-К - ничья
К-Н - победа
К-Б - поражение
Н-К - поражение
Н-Н - ничья
Н-Б - победа
Б-К - победа
Б-Н - поражение
Б-Б - ничья

Из них три выигрышных, три проигрышных и три с ничейным исходом. Итого 33,3(3)% или ⅓ для каждого из трёх возможных итогов.

А теперь внимание на следующие три строчки кода:

from random import choice
DATA = ('победа', 'поражение', 'ничья',)
choice(DATA)

1. Импортируем функцию choice для выбора случайного элемента последовательности.
2. Формируем кортеж с результирующими вариантами. Их ровно три.
3. Выбираем случайным образом 1 из 3 вариантов, т.е. с вероятностью 33,3(3)% или ⅓.

Итого игра сохраняет вероятность 1 к 3, но полностью игнорирует выбор игрока. Всё по честному. Случайность, а не вы определяет победителя. 🤷‍♂️😅

День знаний закончился. Решил научить вас плохому 🤓
Блокбастер "Как написать поиск чисел Фибоначчи в пару строк" или завали себя на собеседовании сам. 😈

fn, f1, f2 = int(input("До какого числа искать Фибоначчи? ")), 0, 1
for f in range(fn): print(f'{f} = {f1}'); f1, f2 = f2, f1 + f2

Код отлично работает. Поставленная задача решена. Просто и компактно. Но...
Предлагаю накидать список недочётов в комментарии. А завтра подведу итог отдельным постом.
Вперёд к знаниям 😉

Продолжение вчерашнего поста о том, как завалить собеседование. Идём по пунктам:
• Имена переменных на f - не лучшая идея. Начинает пестрит в глазах. При чём у всей команды 🤪
• Смешать инициализацию переменных начальными числами Фибоначчи и пользовательский ввод - фу, так не делают. Почему? См. следующий пункт.
• Ввод пользователя не проходит никаких проверок. Ужас 😱 Стоит ввести "плохой текст" и вылетаем с ошибкой. Да и не натуральные числа стоит фильтровать.
• Финальный гвоздь в крышку гроба - точка с запятой ради записи цикла в одну строку. Опытные Python разработчики не будут использовать ; где попало. Скорее всего вообще не будут использовать. 🚫

Такой вариант решения подошёл бы куда лучше. И даже сюда можно добавить def и name main для универсальности:

while True:
    try:
        limit = int(input("До какого числа искать Фибоначчи? "))
    except ValueError:
        print("Нужно натуральное число, а не текст!")
        continue
    if limit < 1:
        print("Нужно число от одного и выше!")
    else:
        break
    
f1, f2 = 0, 1
for i in range(limit):
    print(f'{i} = {f1}')
    f1, f2 = f2, f1 + f2 



P.S. Наличие точки с запятой в коде подразумевает вопрос о других ЯП, где подобный стиль обязателен. И серию вопросов по ним. Хорошо, если в команду устраивается специалист с богатым опытом разработки. В противном случае весело смотреть как он самосливается по всем фронтам языкам.

Все знают, что import принято писать в начале файла. И обычно все знают об особенностях сортировки импортов.
Offtop mode on
Если нет, дайте знать, расскажу в следующем посте.
Offtop mode off
А ещё каждому известно, что Python дружелюбен и готов простить строку import в середине кода.
Но есть страшная тайна о манипуляциях со временем, и путешествием в будущее, которое нельзя отложить на потом. 🤫
Да, вы верно догадались. Речь об импорте будущего. А если быть точным о:
from __future__ import ...
Получим:
SyntaxError: from __future__ imports must occur at the beginning of the file
Как ни крути, а импортировать будущее можно лишь в начале пути.

И да, вопрос об использовании в Python точки с запятой вызывает споры среди неокрепших умов джуниоров и тех, кто привык к ним в Си-подобных языках.
Но что точно неоспоримо, так это отказ от фигурных скобок. Даже в далёком будущем и с импортом в начале файла:
from __future__ import braces
нет и шанса на работу с фигурными скобками:
SyntaxError: not a chance
🤓

Поздравляю с днём программиста 💻

Немного кода для чтения байт порциями 🍰

from functools import partial

BLOCK_SIZE = 64
path = '/home/user/bindata.bin'

with open(path, 'rb') as f:
    for block in iter(partial(f.read, BLOCK_SIZE), b''):
        print(block)

Если коротко, то открываем бинарный файл и считываем блоки байт фиксированного размера до конца файла.

А если подробнее, то:
- получаем указатель на файл, который открыли для чтения байт;
- в цикле функция partial читает из файла блоки размером в BLOCK_SIZE байт;
- функция iter позволяет работать с полученными блоками в цикле, сохраняя их последовательно в переменную block;
- цикл завершается когда iter получает на вход пустой блок - b''. Он указан в качестве второго аргумента функции;
- print в примере для красоты. Не писать же тайный код, который обрабатывает бинарник. У каждого он свой 😉

По (не)многочисленным просьбам немногочисленных подписчиков пост о сортировке импортов.

Открою секрет, никто их не сортирует. Всего лишь упорядочивают по правилу:
1. Модули из стандартной библиотеки
2. Модули из PyPI, он же Python Package Index, он же pip install ...
3. Свои модули

Между группами оставляют пустую строку. Внутри группы сначала идут import и import as. Далее from import и from import as.

Подобный стиль облегчает чтение кода коллег. Дайте знак-реакцию знали ли вы о подобных рекомендациях и используете ли эти знания 😉

import random as rnd
from pprint import pprint

import requests
import numpy as np

from models import User
from best_package.best_module import best_func as bf



P.S. Павел, персональный лайк 👍

Однажды подписчик канала прислал такой код 👨‍💻

with open(path, 'rb') as f:
    block = f.read(BLOCK_SIZE)
    while block:
        print(block)
        block = f.read(BLOCK_SIZE)

Предполагаем, что константа и путь до файла определены выше. Но всё равно что-то тут не так. Мы используем в коде две одинаковые строки
block = f.read(BLOCK_SIZE) и тем самым нарушаем главный закон вселенной принцип Don't Repeat Yourself (DRY) 😱

В такой ситуации стоит посылать всех к моржу 🦭

BLOCK_SIZE = 64
path = '/home/user/bindata.bin'

with open(path, 'rb') as f:
    while block := f.read(BLOCK_SIZE)
        print(block)

Моржовый оператор

16 октября 2000 года вышел Python 2.0
По сути это было очередное плановое обновление Python, но двухтысячный год добавил свои 2K нотки.
Всех, кто застал или не застал Py2K поздравляю с памятной датой. 🎂

P.S. На картинке иконка Py2K. О паре стилизованных змеек тогда никто и не думал. 😉

После одного мема вспомнилась реальная история. Смешная и страшная одновременно. 😂😱

Итак, коллега по коду решил оценить асимптотику своего кода. Делал подобное он впервые. Поэтому с огромной гордостью заявил, что написал код обработки массива данных за константное время. Вау! Круто!
Далее выясняется, что это время равно 3.5 секундам, что на микромассиве из 10 элементов, что на массиве из 10_000. 🤔

Забегу вперёд, нобелевку ему не дали не смотря на верно работающий код. Почему? Замеры делались не верно. 😥
Коллега прикрутил input, чтобы вручную задавать параметры замеров. Но вместо того, чтобы передавать их в оцениваемый код, он прописал их внутри кода. 🤯
Как результат 3.5 секунды на ввод данных. Плюс 0.000002 секунды на обсчёт 10 элементов. Или плюс 0.002 на обсчёт 10к элементов.

Выводы делайте сами. Отличного дня 😉

Немного смайликов в пятничную ленту. 😉

Знаете ли вы, что в основе синтаксиса Python лежит латиница и английский алфавит? Конечно знаете. 😄

А знаете ли вы, что Python 3 отлично работает с любыми символами из UTF-8 внутри str? 😏

def is_prime(num: int) -> bool:
    f['🤓'] = num
    for f['🏃‍'] in range(f['👫'], f['🤓']):
        if f['🤓'] % f['🏃‍'] == f['🤪']:
            return f['😈']
    return f['😇']


f = {'😇': True,
     '😈': False,
     '🤪': 0,
     '👫': 2,
     '🤯': is_prime,
     }

print(f['🤯'](73))

Отличной всем пятницы 🙃

P.S. Программа проверяет является ли число простым. 😁

Проводя собеседования речь иногда заходит об ООП в Python. И 9 из 10 участников не могут внятно ответить что такое self. 😱
Ловите несколько фактов.

- self не является частью синтаксиса. Вместо него можно писать this, me, что угодно. Python вас поймёт. Коллеги по проекту - нет.

- количество параметров в методе класса всегда на один больше, чем количество принимаемых аргументов. Первый параметр self не принимает аргумент в привычном стиле.

- self является указателем экземпляру класса на самого себя.

Взгляните на код:

class User:
    def __init__(self, name):
        self.name = name
        print(f'{self  = }')

    def me(self):
        return self


user1 = User('Python')
print(f'{user1 = }')
user2 = User('Python')
print(f'{user2 = }')

print(user1 is user1.me())

Казалось бы два одинаковых экземпляра класса user1 и user2. Но каждый занимает своё место в оперативной памяти. Адреса не совпадают.

self  = <__main__.User object at 0x00000283CD2BE1D0>
user1 = <__main__.User object at 0x00000283CD2BE1D0>
self  = <__main__.User object at 0x00000283CD77C7C0>
user2 = <__main__.User object at 0x00000283CD77C7C0>

А вот self экземпляра и сам экземпляр совпадают, т.к. являются одним и тем же объектом. user1 is user1.me() всегда True 🤓

Пост о юных подаванах и опытных сеньорах.

Две недели назад вышел Python 3.11.0. Уже привычное большое ежегодное обновление. Удивительно, что пара знакомых сразу же кинулись ставить его. И не просто ставить, а обновлять версию в своих рабочих и pet проектах. 😱
Обратите внимание, что даже у Python 3.10.8 от 11 октября статус bugfix.

Коллеги айтишники, используйте безопасные стабильные версии софта в ваших проектах. 🙏 Экономия времени и нервов колоссальные. 🤓
А если очень хочется чего-то новенького, экспериментируйте вне рабочих проектов. Да прибудет с вами логика, а с вашими проектами Python 3.9.15 security 💂‍♀

Всех с пятницей 👋

Ни для кого не секрет, что язык Python назван в честь шоу Летающий цирк Монти Пайтон. Но что вы знаете о шоу? 🤔
Как насчёт Священного Грааля? Знаете ли вы о том, что африканская ласточка способна перенести кокос на другой континент? А как насчёт святой гранаты из серии игр про червячков Worms? Откуда она?

Предлагаю проникнуться духом Монти Пайтон и посмотреть полуторачасовой Святой Грааль вместе. Устроим выходные в стиле Python IT Geek. 💻

P.S. Уже заливаю видео в комментарии к посту. 🍿

Коротко о четырёх основных способах выполнения кода в Python

Синхронное выполнение 📄
По сути любая программа с переменными, ветвлениями, циклами и прочим, где действия выполняются строка за строкой. Классика, где Python создаёт один процесс с одним потоком внутри.

Многопоточное выполнение 🗂
Берём синхронный код и запускаем функцию несколько раз для "параллельного" выполнения. Снова один Python процесс внутри которого несколько потоков очень быстро переключаются между собой. Настолько быстро, что кажется словно работают одновременно. Но задействуется один поток в одном ядре CPU.

Многопроцессорное выполнение 📚
Основной Python процесс создаёт другие Python процессы. Внутри синхронное выполнение кода в одном потоке. Снаружи несколько процессов выполняемых одновременно разными ядрами/процессорами ПК.

Асинхронное выполнение 🔀
Снова один процесс с одним потоком внутри. Но синхронные функции превращаются в асинхронные сопрограммы - coroutine. Корутины работают по очереди, переключаясь между собой. Похоже на многопоточность, но переключаются не потоки, а функции внутри одного потока.

В продолжение поста о способах выполнения кода. Немного о том где какой вариант применять

📄 Синхронные решения отлично подходят для небольших, срочных и одноразовых задач. Быстро писать. Легко проводить отладку. Улучшения так же не требуют лишних усилий. И даже если ежечасно парсить сайт и тратить несколько секунд на обработку данных, синхронный код отлично справится с задачей.

🗂 Многопоточные решения создаются для задач с обилием ввода и вывода информации. I/O bound подразумевает ожидание ответов, длительное выполнение запросов и т.п. И пока один поток ждёт свой I/O, другой решает задачу. Тот же пример с парсингом, но не одного, а десятков сайтов одновременно. Быстро по очереди отправляем запросы по одному на поток, а потом обрабатываем в порядке получения ответов.

📚 Многопроцессорные решения нужны для CPU bound задач. Обычно это обработка большого объёма данных, которую можно разбить на части. Например парсим сайт, а он возвращает терабайт в ответ. Каждый процесс обрабатывает свой кусочек терабайта изолировано, а ПК нагружает все ядра процессора. Мы же не зря запустили по одному процессу на каждое ядро CPU.

🔀 Асинхронные решения подходят для I/O bound задач. Стоп! Но ведь потоки для них. Всё верно. Если не придираться к деталям, асинхронный подход можно считать современной альтернативой многопоточных решений. Вполне возможно кто-то из вас сталкивался с потоками в legacy проектах и при обновлении софта менял их на асинхронные корутины.