Интересная задачка дня

Вот на ней почему-то долго засел. Есть еще и более интересные за сегодня, в другие дни выложу или нет, от вас всё зависит.

ссылка на задачу, ссылка на тесты к ней, если без них не решается.

А вообще на этом курсе много таких на подумать. Кто там хотел алгоритмы?) Сегодня прописал два варианта сортировок, которые я временно скипнул на другом курсе...Но от судьбы не уйдешь)

P.S.
Поставьте реакции или напишите коммент под этим постом. А то я не понимаю, надо оно вам или не надо. Практически не вижу тут никакой обратной связи. Грусть(

Доброе времени суток! Занимаемся дальше.

Сделанное за вчера:
🔘) Около 1.5 часа видеолекций( 95 минут, если быть точнее), все еще не лень считать)😄
🔘) Дорешены задачи по спискам и новые в текущей главе - кортежи, словари, множества.
🔘) Пройденные Главы:
1) Словари, кортежи и множества: Темы: Введение в словари (dict). Базовые операции над словарями; Методы словаря, перебор элементов словаря в цикле; Кортежи (tuple) и их методы; Множества (set) и их методы; Операции над множествами, сравнение множеств; Генераторы множеств и генераторы словарей; Моржёвый операторация присваивания


Так же ниже будет список, основных моментов, которые были в этой теории. Можете себя проверить всё ли вы знаете как работает😈😈😈
Поехали:
Словари: {ключ1: значение1, ключ2: значение2}, создать словарь: d = {}, d =dict(), получение значения d[key] = value; основные методы словарей: fromkeys(), clear(), get(), setdefault(), pop(), popitem(), d.keys(), d.values(), d.items(), d.update();
Кортежи: - даже не знаю что написать, оч мало было. методы: index(), count() (плюс в чат, если ты это читаешь, проверим сколько таких)😑
Множества: создать пустое: set(), методы: add(), remove(), discard(), update(), pop(), clear(), операции со множествами: пересечение - &, объединение - |, setA.intersection_update(setB), setA.union(setB), вычитание - setA - setB, симметричная разность - ^; сравнение множеств: >, >=, <, <=, ==, !=,
Генераторы: например : множество a = {x 2 for x in range(1, 5)}, словарь a = {x: x 2 for x in range(1, 5)},

Важные моменты из этого материала:
1) Словари в ключах могут содержать только неизменяемые типы данных. Причем элемента ключа должны быть так же неизменяемы, иначе словите ошибку "unhashable type: 'list'"
2) Различие методов при удалении элемента словаря: d.remove(), d.discard(). В 1 случае вызовет ошибку, если нет ключа в словаре, во втором - нет
3) Кортежи - это неизменяемый тип данных. Однако изменяемые элементы его мы можем поменять🤓 Т.к. всё в питоне на ссылках на объекты завязано. Значит ссылку мы не меняем, а объект, на который ссылается эта ссылка можем сделать другим. И ничего не нарушим, кортеж остается тем же. т.е. его элементы будут ссылаться на изначальные объекты.
4) При копирование кортежа срезом по типу t[::] не будет получен новый кортеж, а просто будет еще одна переменная с сылкой на изначальный кортеж, который мы хотели копировать срезом.(со списками, например мы получаем новый объект)
5) Элементами множества могут быть только неизменяемые типы данных! При попытке запихнуть туда например список, получим ошибку, как в 1 пункте.
6) Генераторы. Не существует генератора кортежей, есть просто генератор, из которого мы можем получит кортеж при помощи встроенной функии tuple().
7) Морж. Самый "ленивая" операция присваивания. Имеет наименьше приоритет,т.е. срабатывает самой последней. И дабы избежать ошибок, всегда лучше оборачивать в скобки выражения типо (n = int(input())), или какие-то другие. Сколько раз я себя на этом ловил...теперь всегда оборачиваю в скобки его. Плюс так же лишний раз его лучше стараться не использовать, чтобы не получить неожидаемой работы программы. И такое может быть🙃

Итоги дня и выводы:
Сейчас закончил главу 6, про словари, множества, кортежи. На самом деле она составлена слабее, по сравнению с другими. Можно было б разделить на три и дописать побольше. Многие моменты не рассказаны. Пробежались вскользь. На каждый тип данных по 1 видосу, ну и дальше еще немного практики с их методами. Такими темпами, если проходить по 1 главе в день, то скоро закончу и перейду к ООП.

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

Интересная задачка дня:
ссылка на саму задачу, на ее тесты

Интересно как вы ее решите, мне кажется у меня был не самый лучший подход🫣. Хотелось бы сравнить - Скидывайте код в комментарии😈Немного позже напишу свой вариант под постом в закрытом виде.

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

Сделанное за вчера:
🔘) Чуть больше 2 видеолекций (129 минут, если быть точнее), все еще не лень считать)😄И плюс это же не Докер😂
🔘) Решены все, кроме одной, задачи по этим темам.
🔘) Пройдена глава про функии, частично:
1) Функции: Темы: Что такое функции, объявление и вызов; оператор return, алгоритм Евклида, параметры и аргументы функций, произвольное кол-во параметров в функции (*args, kwargs), операторы *, ** для распаковки коллекций, рекурсивные функции, анонимные (lambda) функции.


Кто захочет более подробно - почитает тут (первые 8 тем слева)


Основные моменты из этого материала:
1) def funс(): pass. func - это лишь ссылка на функцию, а чтобы ее вызвать необходимо после имени добавить (). В ООП потом пригодится.
2) функция всегда что-то возвращает оператором return, по умолчанию это None. Поэтому некоторые методы меняют переменную на месте, а некоторые возвращают новый объект. (методы списков vs методы строк)
3) необходимо отличать параметры функции от аргументов функций. Параметры - это то что передается в функцию, когда мы ее создаем, а аргументы - то, когда вызываем. Т.е. получается, что аргументы функции ссылаются на параметры, заданные при ее объявлении(так, мысли вслух)
4) переменные объявленные в теле функции доступны только в ней (P.S. в самом простом случае, без доп. данных)
5) обязательные(фактические) и необязательные(параметры по умолчанию/формальные). По разному называются, но смысл один. Сначала записываются первые, потом вторые.
6) *args - обязательных параметров, **kwargs - словарь параметров по умолчанию. Так принято называть, если мы создаем функцию и заранее не известно сколько там будет параметров или аргументов при ее вызове.
7) lambda - функция. Функция в одну строчку, без оператора return. Простой формат применения. lambda x, y: x + y. Где слева от двоеточия параметры, которые она принимает, а справа, что возвращает.
8) рекурсивная функция - это та, которая вызывает саму себя, либо в теле функции, либо в операторе return. Но не забывайте условие для выхода в этом случае.


Итоги дня и выводы:
На самом деле это одна из важных тем и лучше ее понимать хорошо. Функции Абсолютно везде используются в программировании. Например, я помню как несколько лет назад мне дали небольшое тестовое и я там нагородил штук 300 кода)А по итогу можно было и за 50, если не меньше, управится. Естественно я дальше не прошёл, но тогда я удивлялся почему же так произошло😂😂😂Благо мне хоть дали обратную связь и сказали про функциональный подход в программировании. Don't Repeat Yourself.

Так, кофе сегодня уже выпил. Осталось дело за малым))
А у вас какие планы на выходные?)🙃

Всем доброе утро! Ну а что? Считаю, когда проснулся - тогда и утро😼

Так вот, вчера просмотрел теорию по темам ниже, порешал задачки. Но оставил несколько штук на завтра, чтобы еще раз просмотреть видео и прорешать еще раз, так сказать обновить багаж забытых знаний. Но тут я попал я попал в какое-то утро сурка😬 (Отсылка к фильму "день сурка", вдруг кто не видел). Проснулся ж значит, и по плану было повторить темы замыкания, декораторы. и декораторы с параметрами. Достал наушники, (чтобы соседи не мешали своим ремонтом😬😬😬). включаю значит. Тему с замыканиями прослушал. Дальше декораторы пошли. И хоба, прикемарил на минуте 3-5-ой. Смотрел с закрытыми глазами. Думаю ну ладно, раз последнюю часть не помню - дай повторю. Ииии...опять уснул. В итоге так было раз 5😂😂😂Дольше 5 минуты видео не доходил. В итоге потом с открытыми глазами дослушал. Ах да, я еще поставил изначально скорость на 0.75(мб поэтому и засыпал), чтобы лучше понять. Хотя автор и так достаточно не быстро говорить, но решил все равно замедлить, дабы не останавливать видео на каких-то моментах каждый. раз. Вот такое вот утро вышло. Только в дне сурка главный герой много чего разного успевал изучить, а я, блин, один и тот же материал по кругу, не до конца😢

Сделанное за вчера и сегодня утро:
🔘) Почти час видео (150+ минут, если быть точнее😑😑😑), все еще не лень считать)😄
🔘) Дорешены задачи в этой главе 👇
🔘) Допройдена глава про функции:
1) Функции: Темы: Области видимости переменных. Ключевые слова global и nonlocal; Замыкания в Python; Декораторы функций, Декораторы с параметрами

Более подробно - почитает тут (первые 9-12 тем слева)

Основные моменты из этого материала:
1) Замыкания. Сейчас на кривом русском попробую объяснить как я это понимаю.🙃Мне кажется на собесе лучше так не отвечать😂Читайте на свой страх и риск запутаться😅
Крч. как я вижу это, Если мы создаем функцию, внутри которой создается другая функция. Затем мы возвращаем внутреннюю функцию(без вызова). просто ссылку(имя) на нее. Далее в программе результат вызова внешней функции присваиваем какой-то глобальной переменной - это и будет ссылка на нашу внутреннюю функцию. И можем ее вызывать, причем с теми переменными, которые были в параметрах внешней функции. Хотя казалось бы внешняя функция уже завершила свою работу( мы ее же вызывали). Однако, пока у нас имеется глобальная ссылка на внутреннее локальное окружение(внутренней функции), то это окружение не удаляется сборщиком мусора, и поэтому существует и следующее внешнее окружение внешней функции для этой внутренней функции, и т.д. А значит и все переменные для внутренней функций из внешней. Уф🫣
отом отдельный пост, с картинкой и пояснением из текста автора, так думаю будет нагляднее
2) Декораторы. Это и есть замыкания, на них они работают. Декораторы - это "обёртка" для функии. Т.е. позволяет изменить поведение функции, не изменяя ее саму. Логика такая же как в замыканиях.
3) Декораторы с параметрами. Это тот же декоратор, но только мы обычный декоратор оборачиваем еще одной функцией, в параметры которые можем что-то передать. Тем самым еще добавить изменений, к уже обновленной версии работы функции.

Простой пример. Есть функция, которая считает значение косинуса в точке "х"(которую мы передаем в эту функцию". Мы можем создать декоратор, который будет считать производную численно с какой-то фиксированной точностью dx. Т.е. функция вместо косинуса х будет считать значение производной в этой точке. А если декоратор с параметрами. то мы можем например выбирать эту точность dx, до нужной нам дельты. Вот и вся суть🙃

Итоги дня и выводы:
Ой помню как у меня полыхало в первый раз от непонимания этих тем😂Но потом разобрался и все прошло) Не отчаивайтесь если что-то не получается, просто вам нужно чуть больше времени и практики для этого. А в данном случае главное понять как работают области видимости и замыкание, и тогда проблем с декораторами не будет. А если как я иногда забываете в них что-то - ничего страшного, потом легко можете восполнить знания, повторив теорию и написав несколько штук.

Немного повозмущаюсь🙂Проснулся сегодня в 9 утра. Нет, не по будильнику, а по стуку соседей от ремонта😬 Ни стыда, ни совести. Мало того что выходной, так еще и праздник сегодня. Кстати, если есть тут учителя, то с праздником вас!)

Вчерашние занятия:
🔘) Около полутора часа видео (88+ минут, если быть точнее), все еще не лень считать)😄
🔘) Тесты все по темам👇 сделаны, т.к. там почти нет задач.
🔘) Пройдена глава про👇:
1) Модули и пакеты. Работа с файлами: Темы: Импорт стандартных модулей. Команды import и from; Импорт собственных модулей; Установка сторонних модулей (pip install). Пакетная установка; Пакеты (package) в Python. Вложенные пакеты; Функция open. Чтение данных из файла; Исключение FileNotFoundError и менеджер контекста (with) для файлов; Запись данных в файл в текстовом и бинарном режимах.

подробно - почитаете тут слева

Основные моменты из этого материала:
0) Для начала что такое модули пакеты.
Модуль - это просто любая программа на питоне с расширением "py", а пакет - это набор(в папке) таких модулей, но где еще присутствует файл __init__.py. В нем прописывается, что будет импортироваться при команде import my_packet. Более подробно изучите сами.
1) Import.
Думаю уже все вы хоть раз этим пользовались. И знаете как это использовать, но есть несколько ньюансов и как лучше это делать. Например не надо импортировать всё, через звездочку(*). Может возникнуть конфликт имен при подключении нескольких модулей, не понятно какая функция откуда взята, в случае ошибки или неверной работы программы. Можно так же создавать эллиасы импортируемых переменных, функций, и т.д. для более короткого кода и/или возможности например задать в программе переменную/функцию с таким же именем.

Когда вы импортируете модуль в Python (с помощью import), весь его код выполняется сразу же, при чем не важно отправили ли вы весь модуль или конкретно что-то. Т.е. если у вас есть какие-то принты или вызовы функций и т.д., то они выполнятся. Это важно понимать. Я раньше не догонял почему так происходит...Ведь я же не весь собственный модуль импортировал, а только необходимые мне данные. И комментировал лишние вызовы😅 Но это можно сделать проще. Если вы не хотите, чтобы какие-то команды исполнялись в другом файле при импортировании в него другого модуля, достаточно в нем прописать:

if __name__ == '__main__':
    # блок команд, которые не должны выполнять при импорте
    print(f'Я хочу вывестись в другом модуле, но мне не дают это сделать!(')

Если вы запустите файл с таким содержимым напрямую, вы выполните строчки в пространстве после if. Если же вы импортируете этот модуль внутри другого файла, то код внутри этого блока не выполнится там. Так происходит потому что специальная переменная "__name__" содержит имя модуля. При прямом запуске файла она принимает значение "__main__", а при импорте — имя своего модуля. Поэтому при импорте не выполняется условие проверки и код внутри не выполняется. Надеюсь понятно объяснил)
2) Работа с файлом
Лучше всего работать с файлами из менеджера контекста. А еще желательно обворачивать это в блок в try-except. Это нужно для того, чтобы не потерять данные или не повредить файл при неуспешой работе с ним. (хотя я пока что такого не видел, но так говорят что надо😅)
3) Режимы при работе с файлом.
Есть несколько основных 'r' - от 'read' - при чтении файла, 'w' - от 'write' - при записи в файл(создает файл если не было, и перезаписывает все данные в нем, если были), 'a' от 'append' - при дозаписи в конец файла.
4) Относительные и абсолютные пути для открытия файла.

Итоги дня и выводы:
Относительно чиловый день выдался. Посмотрел, поотвечал на тесты. Но не понравилось что нет практических задач в этой главе. Так же про взаимодействие с json не рассказано. А думается мне, что с ним больше всего надо быть знакомым и уметь загружать и распарсивать данные с этим типом данных, хотя логика взаимодействия такая же. От малой практики в этой теме до сих пор путаю load(), dump(). Что грузит, чтто парсит🫡🫡🫡Есть такие же тут или я один такой забывчивый?)😁

Вчера проходил предпоследнюю главу в текущем курсе. Но не всё так гладко вышло, как хотелось бы)

Прошел половину, встрял на задачах с zip. Какие-то муторные мне они показались. Чё-то там свернуть, развернуть, запаковать, распаковать..Ну либо, скорее всего, я чего-то не понял до конца. Крч, решил отдохнуть. Отдых растянулся, ну и естественно к учебе больше вчера не притронулся)))

Сегодня с утра(когда проснулся) начал заниматься. Думал, быстренько закончу и начну новую главу. Ага не тут то было)) Несмотря на то, что оставшиеся темы: all, any, isinstance, type, sort,sorted(key=lambda x: бла_бла_бла(x)) я ранее проходил, но застрял на задачках больше, чем планировал. В итоге только сейчас закончил.

Скоро напишу поподробнее об этом.

Не любители длинных текстов сразу листайте к концу поста🫡🫡🫡

Вчера + сегодня полдня:
✅) Теория - 77 минут видео
✅) Практика - задачи по ней же 👇
✅) Завершена глава про:
1) Генераторы и некоторые полезные функции: Темы: Выражения генераторы; Функция-генератор. Оператор yield; Функции: map, filter, zip, any, all, isinstance, type; Особенности сортировки через sort() и sorted(), key=lambda;

Подробнее уже сами знаете где найти.

Основные моменты из этого материала:
1) Выражения-генераторы:
Это объект-генератор. Можно получить из него значения по одному через метод next(). При переборе всех элементов становится пустым. Если после истощения вызывать next - словим ошибку "StopIteration". Так же является итерируемым объектом, поэтому можно перебирать и через цикл for, например.
2) Функция-генератор:
В принципе тоже самое что предыдущий пункт. Только есть отличие от обычных. В этой функции вместо return прописывают yield. И после этого оператора yield обычная функция становится функией-генератором. Так же «замораживает» свое состояние, вместе с локальными переменными до следующего вызова функции next(). В этом и заключается роль оператора yield.
3) Сортировка sort(), sorted():
По умолчанию сортировка ведется по значениям элементов коллекции. Но мы можем упорядочить с помощью различных способов, передавая в аргумент "key" функцию, по результатам которой будут сортироваться наши данные. Простой пример допустим у нас есть список lst = ["Москва", "Тверь", "Смоленск", "Псков", "Рязань"]:

print( sorted(lst, key=len)
print( sorted(lst, key=lambda x: x[-1]), reverse=True)

возвращает список, упорядоченный по длине слов в нем, а во втором варианте - сортировка по последней букве слова в обратном порядке. Можно реализовывать и более сложные варианты, все в вашей фантазии)
4) Проверка типа объекта:
isinstance() vs type() возвращают True или False. У обоих одинаковый функционал, с небольшим различием. type() проверяет точное совпадение с типом данных, а isinstance() в отличие от type() делает проверку с учетом иерархии наследования объектов и была разработана для проверки принадлежности объекта тому или иному классу. Например, тип bool наследуется от int, поэтому isinstance() выдает True для типов int и bool; a type() выдаст True и False соответственно.
5) any, all, filter:
Используйте для фильтрации ваших данных, простой синтаксис - добавить нечего)

Заключение:
После этой главы вы будете: Понимать что такое генератор и функция-генератор. Уметь пользоваться функциями для сортировки значений. Умело применять возможности для фильтрации и проверки данных. Проверять правильно типы данных объектов. Ну и map😁

Интересная задачка дня

Задача, тесты к ней

Не помню уже почему, но ее скипнул при решение. Возможно что-то не чисто там🤔 Но на взляд выглядит не сложно. Хотя успешный процент решений ниже среднего.🤔

P.S.
Тут как раз пригодится метод rjust(). Ну это один из вариантов для нужного вывода.

Такс, завершил последнюю главу по доброму курсу🤓🤓🤓

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

Что тут было::
✅) Теория - 103 минуты видео
✅) Практика - задачи по ней же 👇
✅) Завершена глава про:
1) Движемся дальше, вглубь😅: Темы: Расширенное представление чисел. Системы счисления; Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы; Модуль random стандартной библиотеки; Конструкция match/case: Первое знакомство, примеры со словарями, множествами, списками, кортежами.

Подробнее уже сами знаете где найти.

Основные моменты из этого материала:
1) Конструкция Маtch-case:
Приведу самый простой пример, ибо боюсь что при описывании всех вариантов использования, у меня не хватит буков в посте😄 Пишем "матч", и далее слово, которое будет проверятся по шаблону, если в шаблоне слово после "кейс" подходит под переменную "комманд", то выполняется этот блок кода и конструкция завершает работу, если нет, то идет дальше как в условном операторе.

command = "top"
 
match command:
    case 'left':
        print("влево")
    case "right":
        print("вправо")
    case _:  # wildcard # _ означает абсолютно любой вариант
        print("другое")

Что хочу сказать про эту главу:
Первые темы, какие-то странные: Представление чисел, системы счисления, побитовые операции, "включение" и "выключение" битов по номеру. Полезно? Возможно. Пригодится ли часто? Оч. вряд-ли. Думаю поэтому не хотел садиться за материал, т.к. это не видел нужным в дальнейшем. Еще интересно, что если сравнивать с версией материала на его лично сайте(текстовой), то можно увидеть пропущенные 3 главы, которых нет на Степике. А это про аннотации типов данных, включая классы. Посмотрю на досуге как раз.

Далее модуль random и match-case. Это я ранее проходил уже, и знаю, но плохо помню, т.к. было мало практики. Тоже мешали начать заниматься эти дурацкие мысли... Матч-кейс - это же по сути усовершенствованный if/elif/else, но применять надо с умом, и иногда будет излишнем такая конструкция. И еще момент, когда в другом курсе(Про Код, если не ошибаюсь) проходил match-case, то некоторые задания не смог выполнить и пошел еще искать в других местах теорию. И первым же мне выдало видосы с этой последней главы. Просмотрев буквально несколько минут я уже понимал как мне надо доделать задачу. Т.е. теория тут хороша, но практики чуть маловато. Однако тебя тут не проверяют на базовое применение, а в большинстве случаев бросают на передовую😁

P.S.
Этот пост писал минут 40, ужс.Куда так летит время...

Так, сегодня-завтра небольшой отдых. Надо чтобы знания осели в голове😁Хотя какой там. Буду дорешивать пропущенные задачки из последних двух курсов. Чую сегодня у меня немножко подгорит)))

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