Python (читается как «Пайтон») — предлагаю остановиться на этой теме 🐍


Сейчас Python - является широко распространенным языком программирования, который применяется во многих областях, например:

• Разработка прикладного ПО.

• Разработка web-приложений.

• Использование в качестве встраиваемого скриптового языка во многих играх, и не только (3D редактор Blender, СУБД PostgreSQL).

• Использование в научных вычислениях (Для расчетов: пакеты numPy и SciPy. Для рисования графиков: пакет PyPlot. Таким образом, Python может потягаться с пакетами типа MatLab).


Для работы с Python понадобится:

1. Сам интерпретатор, его можно взять тут (https://www.python.org/downloads/).

2. IDE или среда разработки. Отметим, что для начала она необязательна 😎.

В начале будет достаточно интерактивной оболочки самого Python. После установки интерпретатора просто запускаем python.exe 🍿. Приглашение на ввод будет выглядеть так:

>>>

Также есть возможность записывать программы в файлы с расширением .py в вашем любимом текстовом редакторе (например: "Блокнот", "Notepad++"). Для запуска файлов на выполнение можно кликнуть по ним 2 раза. Если консольное окно закрывается слишком быстро, можно в конце программы дописать следующую строку:

input()

В таком случае, интерпретатор будет ждать в конце программы нажатия enter 😎.

Также, можно воспользоваться одной из многих удобных IDE для Python (Например: "Visual Studio", "Spyder", "PyCharm"), в которых есть возможность отладки кода, подсветки синтаксиса и многие другие удобства.


Предлагаю добавить немного теории:
Python — язык со строгой динамической неявной типизацией.

Что это означает?
Смотри ответ ниже 👇.

• "Строгая" означает, что язык не производит неявные преобразования типов переменных и не создаёт сюрпризов при их случайном смешении (если такое все-таки произойдет - выскочит ошибка ☹️).

• "Динамическая" означает, что типы переменных определяются в процессе выполнения программы.

• "Неявная" означает, что тип‌ ‌переменной‌ ‌определяется‌ ‌интерпретатором‌ ‌или‌ ‌компилятором.

Также:

• Присваивание значения переменной осуществляется с помощью знака "=".

• В Python нет специального ограничителя для блоков кода, их роль выполняют отступы. То есть то, что написано с одинаковым отступом — является одним командным блоком 1️⃣.


Теперь добавим немного практики:

• Условия:
Условие задается с помощью оператора " if ", который заканчивается символом " : ". Альтернативные условия, которые будут выполняться, если первая проверка неуспешна, задаются оператором " elif ". Наконец, " else " задает ветку, которая будет выполнена в случае если ни одно из условий не выполняется 😭.

Пример:

>>> x = 13
>>> if (x<10) or (x>20):
...     print("x не подходит")
... elif (10<x<20):
...     print("x подходит!")
... else:
...     print("x выколотая точка")
...
x подходит!

• Циклы:
Простейшим видом цикла является цикл " while ". В качестве параметра он принимает условие и выполняется до тех пор, пока это условие является истиной.

Пример:

>>> x = 0
>>> while(x<=3):
...     print(x)
...     x += 1
...
0
1
2
3

Также, в Python существует вид цикла " for ", в котором переменной будут присваиваться (по очереди) все значения из списка.

Пример, в котором в роли списка - строка❤️:

>>> x = "Привет"
>>> for char in x:
...     print(char)
...
П
р
и
в
е
т

Пример с циклом, который повторяется n-раз:

>>> for x in range(4):
...     print(x)
...
0
1
2
3

На этом предлагаю остановиться. Продолжение в следующем посте 🤫.


#статья 📚

И снова наш любимый Python 😭 — предлагаю начать с основ и коснуться переменных и операций над числами.


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

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


Синтаксис объявления переменной можно упаковать в следующую "формулу":

"Наименование переменной" + "=" + "Значение переменной"

Вот пару примеров того, как объявляется (создается 😎) переменная:

first = "синий"
second = 23

Естественно, что у разных переменных могут быть разные типы данных. В примере выше:
• переменная "first" является строкой;
• переменная "second" является числом.


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

first = "синий"
second = 23
print(first, second)

Если запустить такую программу в каком-нибудь онлайн компиляторе или, например, в Jupyter Notebook (как это сделал я 😮‍💨) — нам будет выведено:

синий 23

Теперь опишем несколько правил, которых следует придерживаться при выборе имен переменных 👇:

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

2. Имя переменной не должно содержать пробелов.

3. Имя переменной не должно начинаться с цифры.

4. Регистр важен (first и First это разные переменные).

5. Учитывайте, что некоторые наименования могут быть зарезервированы (это ключевые слова, например: "False, True, for, while и т.д." и наименования встроенных функций, например: "abs(), bool(), и т.д.").


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

Рассмотрим пример:

a = 10 + 5
b = a + 20
c = (a + b) * 2
print(a, b, c)

После запуска такой программы нам будет выведен текст:

15 35 100

Предлагаю разобраться поподробнее 🫡:

1. В первой строке переменной "a" будет присвоено значение суммы чисел 10 и 5.

2. Во второй строке мы складываем значение переменной "a" и число 20. В итоге в переменную "b" будет записано число 35.

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


В завершении опишем арифметические операторы, которые можно использовать в Python (10 + 5 = 15, где "10" и "5" это операнды, а "+" это оператор) ✍️:

• " + " (Добавление) - добавляет левый операнд к правому. Пример: "a + b = 15", где a = 10, b = 5;

• " - " (Вычитание) - вычитает правый операнд из левого. Пример: "a - b = 5";

• " * " (Умножение) - умножает левый операнд на правый. Пример: "a * b = 50";

• " / " (Деление) - делит левый операнд на правый. Пример: "a / b = 2";

• " % " (Деление по модулю) - делит левый операнд на правый и возвращает остаток. Пример: "a % b = 0";

• " ** " (Возведение в степень) - возводит левый операнд в степень, которая равна правому операнду. Пример: "a ** b = 100000";

• " // " (Целочисленное деление) - деление в котором возвращается только целая часть результата, а часть после запятой отбрасывается. Пример: "9 // 2 = 4".

#статья 📚

Продолжим серию постов про Python 🍎. Предлагаю разобрать строки 🌈.


Строка — это тип данных, который нужен для работы с текстом. Для того, чтобы создать строку в Python, нужно "обернуть" значение переменной в одинарные (') или двойные кавычки ("). Если нужно использовать большое количество текста, который занимает несколько строк, в рамках одной переменной, можно "оборачивать" этот текст в тройные кавычки (''' или """) 😄. Приведем пример:

a = 'Привет, друг!'
b = "Как дела?"
c = """очень-очень-очень
длинный текст, который
занимает несколько строк"""

print(a)
print(b)
print(c)

Если запустить код, который описан выше, будет выведено следующее 😎:

Привет, друг!
Как дела?
очень-очень-очень
длинный текст, который
занимает несколько строк

Помимо создания строк в исходном коде (описано выше 👆), можно получать строку от пользователя с помощью функции "input()". Предлагаю сразу разобрать пример:

name = input('Введите свое имя: ')
surname = input('Введите свою фамилию: ')
privetstvie = "Привет, " + name + " " + surname
print(privetstvie)

При запуске такой программы пользователь получит приглашение ввести свое имя, а затем фамилию. Как только это будет сделано, в переменную name будет записано имя, которое он ввел, а в переменную surname будет записана фамилия, которую он ввел 1️⃣.

В третьей строке программы есть оператор " + ", про который можно почитать в предыдущем посте. В данном случае, с его помощью несколько строк склеиваются в одну (этот процесс также можно называть "конкатенацией строк").

Четвертая строка выведет целое приветствие на экран 👋. То есть, если пользователь введет имя "Андрей", а затем фамилию "Разыграев" (все совпадения случайны ☹️), то будет выведено следующее:

Привет, Андрей Разыграев

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

• a = "" (Это пустая строка ☔️)

• b = " " (Это строка, которая состоит из одного пробела 💪)

Ну и напоследок, предлагаю разобрать простую, но очень полезную встроенную функцию, с помощью которой можно узнать длину строки ❤️. Это функция:

• len() – возвращает количество символов строки

Сразу приведем пример использования этой функции:

stroka = input('Введите любой текст: ')
a = len(stroka)
print(a)

Допустим, что после запуска программы, пользователь ввел следующий текст "Интересно, какое количество символов в этой строке?" 👍. Тогда, после выполнения программы будет выведено:

51

#статья 📚

Предлагаю разобрать некоторые полезные методы, которые направлены на наши "любимые" строки. Поехали 🍿.


Методы, с помощью которых можно манипулировать (да, именно так 😄) строками, похожи на функции. Их тоже можно вызывать и, так же как и функции, они могут возвращать результат своей работы. Отличаются эти методы тем, что они привязаны к определенному типу данных. Это означает, что, например, методы строк могут быть вызваны только у строк 🙄.

Чтобы не ходить вокруг да около, сразу приведем несколько примеров того, как вызывать эти самые методы строк и безжалостно их использовать ☹️. Напишем, а затем запустим код ниже:

stroka = "Ничего сложного :)"
print(stroka.lower())  
print(stroka.upper())

Вывод после запуска кода будет таким:

ничего сложного :)
НИЧЕГО СЛОЖНОГО :)

То есть метод " .lower() " возвращает строку, в которой все символы находятся в нижнем регистре.
А метод " .upper() ", соответственно, возвращает строку, в которой все символы находятся в верхнем регистре. В параметрах методов (то, что в скобках, после названия метода 😏) ничего указывать не нужно.


Также, очень ! важно ! помнить, что методы не меняют исходную строку. Строки в Python вообще нельзя изменить 🍔. И что тогда делать? Ответ таков: нужно присвоить строке новое значение 1️⃣, пример ниже.

stroka = "Ничего сложного :)"
stroka = stroka.upper()  
print(stroka)

Вывод программы выше будет таким:

НИЧЕГО СЛОЖНОГО :)

Но если мы потом, после компиляции кода выше, будем использовать значение переменной " stroka ", то оно будет равно именно "НИЧЕГО СЛОЖНОГО :)", а не "Ничего сложного :)". Вот такой вот нюанс 🍎!


Теперь рассмотрим самое интересное, но немного душное: индексы строк.

Бывает так, что иногда нужно выбирать отдельные символы из строки. В Python для этого необходимо использовать квадратные скобки: "[...]" 🗿. Ниже приведены примеры получения символа строки s, которая равна слову "Дружище".

Код:

s = "Дружище"
print(s[0])
print(s[1])
print(s[-1])
print(s[-2])

Вывод:

Д
р
е
щ

Видно, что " s[0] " — возвращает первый символ нашей строки, " s[1] " — возвращает второй символ, " s[-1] " — возвращает последний символ, " s[-2] " — возвращает предпоследний символ. Отсюда можем выделить пару несложных правил ✨:

1. Нумерация индексов символов начинается с нуля;

2. Отрицательный индекс отсчитывает символы, начиная с конца строки.

После вышеописанного можем рассмотреть просто душное (шучу ☹️): cрезы строк.

Срез используется для выделения части строки. Он состоит из индекса и диапазона. Сразу рассмотрим несколько примеров со строкой c = "абвгдежзик".

Индексы символов строки "c":

0 1 2 3 4 5 6 7 8 9

Символы строки "c", соответственно:

а б в г д е ж з и к

Тогда, при запуске кода ниже:

c = "абвгдежзик"
print(c[2 : 5])
print(c[ : 5])
print(c[5 : ])
print(c[-2 : ])
print(c[: ])
print(c[1 : 7 : 2])
print(c[: : -1 ])

Вывод будет следующим:

вгд
абвгд
ежзик
ик
абвгдежзик
бге
кизжедгвба

Теперь разберем:

• В 1 строке — вывелись символы с индексами 2,3,4
• В 2 строке — вывелись первые пять символов
• В 3 строке — вывелись символы, начиная с 5 и до конца
• В 4 строке — вывелись два последних символа
• В 5 строке — вывелась вся строка
• В 6 строке — вывелись символы со второго по шестой, через один
• В 7 строке — вывелась стока наоборот (т.к. шагаем по одному символу с конца строки 💪)

Ну и теперь уже по-классике сформулируем из того, что выше несколько правил ❤️:

1. Структуру среза можно представить "формулой": наша_строка[начальный_символ : конечный_символ + 1 : шаг];

2. Срезы не включают явное расположение окончания строки. Например, в приведенном выше примере " c[2 : 5] ", выводятся символы с индексами 2, 3 и 4, но не символ с индексом 5;

3. Мы можем оставить, вместо индекса начала или окончания строки, пустоту (или пробел);

4. Используя отрицательные индексы, мы можем получать символы с конца строки.

#статья 📚

Давайте сделаем небольшое отступление от Python и порассуждаем на тему спорта, дисциплины и зачем это вообще нужно 🤷‍♀️?


Начнем с очевидного, а именно - со спорта 🏋️‍♂️.

Спорт — это не просто физическая активность, это неотъемлемая часть здорового образа жизни (признайтесь, удивил? 😄). Регулярные тренировки приносят много полезного для организма и психического состояния, рассмотрим примеры ниже:

• Укрепляется сердечно-сосудистая система.
• Повышается общий иммунитет организма.
• Уходит лишний вес.
• Укрепляются кости и суставы.
• Повышается выносливость.
• Снижается уровень стресса и тревожности.
• Повышается настроения из-за выработки гормонов счастья (эндорфинов).

Ни для кого не секрет, что спорт дисциплинирует. Но как это происходит? (Сейчас капитан очевидность разберется 😎)

При регулярных занятиях возникает необходимость в:

1. Составлении тренировочного плана. Чтобы достичь своих целей, необходимо составить план тренировок и строго его придерживаться. Это учит планированию и целеустремленности ✨.

2. Регулярности. Регулярные тренировки формируют привычку и помогают развивать силу воли 💪.

3. Преодолении трудностей. Во время тренировок всегда возникают трудности: усталость, боль, желание бросить все 😭. Преодолевая их, вы становитесь более стойким и уверенным в себе и своих силах.


Теперь, когда связь между спортом и дисциплиной явно определена, опишем почему дисциплина >> мотивации. ( >> - означает «много больше» 🍎)

Дисциплина часто оказывается более надежным спутником на пути к достижению целей, чем мотивация, так как:

Мотивация — это переменчивая спутница 🙌.

1. Нестабильность. Мотивация — это как ветер: то дует сильно, то стихает 🥶.

2. Краткосрочность. Мотивация часто основана на эмоциях и краткосрочных целях. Она может помочь начать что-то делать, но не всегда поддержит на протяжении длительного времени 😭.

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

Дисциплина — это надежный фундамент состоящий из таких «кирпичиков» как:

1. Постоянство.
Дисциплина — это привычка делать что-то регулярно, вне зависимости от вашего настроения или внешних факторов (плохая погода, темное время суток) 🤫.

2. Долгосрочность.
Дисциплина направлена на достижение долгосрочных целей. Она помогает следовать намеченному плану ❤️.

3. Независимость.
Дисциплина не зависит от внешних факторов. Она позволяет действовать даже тогда,когда мотивации нет ☹️.

В итоге, можно сделать вывод:

Дисциплина — это ключ к успеху. Она позволяет достигать поставленных целей, несмотря на препятствия и соблазны. Конечно, мотивация тоже играет важную роль, но дисциплина — это то, что помогает нам двигаться вперед даже тогда, когда мотивации нет 1️⃣.

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


#хинт 😮‍💨

Давайте ненадолго вернемся к Python (базовые посты скоро закончатся, правда 😭) и разберем, что такое "Модули".

Если говорить простым языком, то это файлы, в которых содержатся определения функций, определяются значения некоторых переменных (например: число π, число Эйлера и т.д.).

Модули (или библиотеки) нужны для того, чтобы расширить возможности языка программирования и упростить написание программ. Думаю, что именно за это и любят Python ❤️.

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

• Модуль "math" - очень помогает при работе с числами и с простыми математическими функциями (например: sin(x), cos(x) и т.д.).

• Модуль "time" - пригодится для работы со временем 😎.

• Модуль "random" - предоставляет функции для генерации случайных чисел, букв, случайного выбора элементов последовательности ☕️.

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

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

• Допустим, что вы работаете с какими-то сложными математическими вычислениями.

• Вы подключаете модуль со встроенной поддержкой требуемых операций (предварительно посмотрев информацию в гугле 🫡).

• После этого у вас отпадет необходимость придумывать то, что было уже придумано до вас. Можно сразу использовать ☹️.

Стоит также отметить, что сторонние модули могут быть написаны не только на языке Python, но и также на C и C++, а это дает существенный прирост в скорости работы таких модулей (уверен, что среди вас есть любители С и С++ 1️⃣).


Теперь добавим немного практики.

Для того, чтобы импортировать нужный модуль в нашу программу, а затем использовать его, необходимо воспользоваться командой "import".
Также, если нам нужно поменять стандартное имя модуля на кастомное, в рамках нашей программы - будем использовать "as". Формализуем вышесказанное 😄:

import наименование_модуля as кастомное_наименование_модуля

Ниже приведем пример программы, в которой импортируем модуль "math", выведем число π и посчитаем синус нуля:

import math as math_bot

print(math_bot.pi)
print(math_bot.sin(0))

Вывод программы выше будет следующим:

3.141592653589793
0.0

Давайте быстренько разберем написанный код:

• В первой строке импортируем модуль "math", называя его "math_bot" в рамках нашей программы ✨.

• Во второй строке выводим значение, которое возвращает метод "pi" модуля "math" 👍.

• В третьей строке выводим значение, которое возвращает метод "sin()" модуля "math" (в метод sin() - передаем значение равное нулю) 💪.

Вторым примером напишем программу, которая будет выводить 5 случайных целых чисел от 1 до 100 с паузой в одну секунду. Для того, чтобы это сделать импортируем модули "time" и "random":

import time
import random

i = 0

while (i <= 4):
    print(random.randint(1, 100))
    i = i + 1
    time.sleep(1)

Вывод программы будет каждый раз разным, например:

37
21
97
89
92

По классике бегло разберем написанный код нашего рандомайзера 😄:

• Импортируем модули "time" и "random".

• Задаем начальное значение счетчика, который остановит программу.

• Задаем условие остановки цикла while (5 чисел вывели - останавливаемся) 👌.

• В теле цикла выполняем следующие действия: печатаем рандомное число от 0 до 100, увеличиваем наш счетчик на единицу, ждем одну секунду.

Вот такая ночная закидушка вам ✅.


#статья 📚

Давайте сегодня поговорим про число e (число Эйлера) 💡.

Часто говорят, что это число носит статус "магической" константы в математике, но мне в голову приходит следующее: «е, бой» или «е, рок» 😄.

Ну а если серьезно, то число e является фундаментальной математической константой (одной из 🫡). Оно примерно равно:

2,71828182845904…

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


Кратко опишем свойства числа e:

• Число e нельзя представить в виде обыкновенной дроби. Его десятичное представление бесконечно и непериодично.

• Число e не является корнем никакого алгебраического уравнения с целыми коэффициентами.

• Производная функции y = e^x равна e^x. Это свойство делает ее одной из самых важных функций в математическом анализе.

И расскажем про применение числа e:

• Экспоненциальный рост и распад: описывает процессы с постоянной скоростью, такие как рост популяций или радиоактивный распад.

• Финансовые расчеты: используется для вычисления сложных процентов (более подробно про них - ниже ✨).

• Теория вероятностей: применяется в распределении Пуассона и нормальном распределении.

• Компьютерные науки: Используется в функциях активации (привет нейросетям ☕️).

Давайте быстренько распишем: откуда все-таки взялось это число e 🤨?

Число e впервые появилось в связи с изучением сложного процента (это начисление процентов на начисленный ранее процент 🤯).

При непрерывном начислении процентов, сумма вклада растет экспоненциально, и именно число e описывает скорость этого роста.

Сходу разберем пример с этим сложным процентом:

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

S = P * (1 + r/n)^(n*t)


где:

• S - конечная сумма.
• P - начальная сумма вклада.
• r - процентная ставка (в десятичном виде, т.е. 16% = 0.16 ☕️).
• n - количество капитализаций в год (капитализация - начисление процентов на вклад 🧐).
• t - время в годах.

При бесконечно частой капитализации (n стремится к бесконечности), выражение:

(1 + r/n)^(n*t)

стремится к числу e^(r*t), при условии, что r - процентная ставка в десятичном виде, а t - количество лет. В итоге, получаем формулу:

S = P * e^(r*t)

Давайте подставим в нее реальные цифры: предположим, вы положили 1000 рублей под 16% годовых (капитализация происходит раз в год) с непрерывным начислением процентов. Через 5 лет ваша сумма составит 🌈:

S = 1000 * e^(0.16 * 5) ≈ 2225.54 рублей



Если положить 1000 рублей под обычный процент с аналогичными условиями, получим 👊:

S = P + P * r * t = 1000 + 1000 * 0,16 * 5 = 1800 рублей

В итоге, можем сделать вывод, что при непрерывном начислении проценты растут значительно быстрее, чем при обычном начислении 📞.


Вообще, про число е можно написать целую книгу, но делать этого конечно же не будем ☹️.


#статья 📚

⌨️ Лайф: режим, мысли и выводы


Тут собраны лайф-посты про режим, восстановление, перегрузы, поездки, канал и личные выводы.


📁 Отдых и восстановление:

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


📁 Перегруз и откаты:

📎 Как я загнал себя в переутомление
📎 Неделя апатии: разобрал причины
📎 Болезнь и мысли на больничном
📎 Тяжело возвращаться после болезни


📁 Режим и дисциплина:

📎 Спорт и дисциплина: зачем это нужно
📎 Один по-настоящему здравый день
📎 Рабочее место и продуктивность
📎 Две недели налаживал режим


📁 Мысли и рефлексия:

📎 Свой контекст дороже безликого контента
📎 Прогресс: либо растёт, либо падает
📎 Доминанта: как утро задаёт весь день
📎 Рефлексия как рабочий инструмент
📎 Почему с возрастом время летит быстрее
📎 Перфекционизм: почему «ещё не идеально» мешает
📎 Чувство, когда закрыл давние проекты
📎 Зачем читать книги


📁 Поездки и лайф-апдейты:

📎 Работа, спорт, дача и аналитика
📎 Отпуск: Калуга, Тула и дорога на машине
📎 Последний день лета
📎 Долгожданный отпуск в Питере
📎 Поездка на машине в Минск


📁 Про канал:

📎 Куда я пропадал: про аспирантуру
📎 Как выбрать тему для поста
📎 Статистика канала за его первый год
📎 Как я оформляю посты


#навигация 📝

Сегодня поговорим про списки в Python и про то, что с ними делать 📝


Давайте предположим, что вы составляете список гостей на ваш день рождения. Этот список постоянно меняется, например:

• Артем и Антон, в итоге, не смогут прийти 😭.

• Андрей планирует прийти с другом Ваней 1️⃣.

Для работы с такими данными из реального мира отлично подходят списки (кстати, это еще один встроенный тип данных в Python ☕️). Для того, чтобы создать или, как говорится, объявить список в Python можно использовать два способа:

# первый способ
spisok_1 = ['первый', 'второй','третий']

# второй способ
spisok_2 = list('первый')

print(spisok_1, '- первый способ')
print(spisok_2, '- второй способ')

Вывод программы будет следующим:

['первый', 'второй', 'третий'] - первый способ
['п', 'е', 'р', 'в', 'ы', 'й'] - второй способ

Стоит отметить, что функция "list()" из второго способа принимает один объект, который можно "разобрать" на элементы, и возвращает список из этих элементов 👨‍💻. Например, если передать в "list()" строку — получим список букв, из которых эта строка состоит. Передадим в "list()" множество — получим список элементов этого множества ✨.


Теперь предлагаю вернутся к списку гостей на день рождения. Давайте его создадим (перечислим всех возможных гостей через запятую):

guests = ['Валера', 'Саша', 'Артем', 'Антон']

В списке выше четыре элемента: 'Валера', 'Саша', 'Артем', 'Антон' — которые хранятся внутри списка именно в таком порядке. Если вы не собираетесь менять порядок списка, 'Валера' (настало твое время 😄) всегда будет первым элементом, 'Саша' — вторым и т.д.

Мы помним, что Артем и Антон не смогут прийти, поэтому их нужно удалить из нашего списка 😫. Сделаем это с помощью метода ".remove()", который удаляет первое вхождение в список заданного элемента (это означает, что если бы в списке было два элемента 'Артем', то удален бы был только первый ☕️):

guests = ['Валера', 'Саша', 'Артем', 'Антон']
print(guests, '- до удаления')

guests.remove('Артем')
print(guests, '- убрали Артема')

guests.remove('Антон')
print(guests, '- убрали Антона')

После выполнения кода выше будет выведено:

['Валера', 'Саша', 'Артем', 'Антон'] - до удаления
['Валера', 'Саша', 'Антон'] - убрали Артема
['Валера', 'Саша'] - убрали Антона

Теперь нам нужно добавить в список двух гостей, а именно: Андрея и Ваню ✍️. Добавим новые элементы в конец списка с помощью метода ".append()":

guests = ['Валера', 'Саша']
print(guests, '- до добавления')

guests.append('Андрей')
print(guests, '- добавили Андрея')

guests.append('Ваня')
print(guests, '- добавили Ваню')

Вывод будет таким:

['Валера', 'Саша'] - до добавления
['Валера', 'Саша', 'Андрей'] - добавили Андрея
['Валера', 'Саша', 'Андрей', 'Ваня'] - добавили Ваню

Также, есть возможность не только удалять / добавлять элемент, но и изменить его значение на другое, опираясь на индекс элемента (индексация начинается с нуля 🫡). Сходу рассмотрим на примере:

guests = ['Валера', 'Саша', 'Андрей', 'Ваня']
print(guests, '- до изменения')

guests[2] = 'АНДРЮХА'
print(guests, '- после изменений')

Компилируем и получаем:

['Валера', 'Саша', 'Андрей', 'Ваня'] - до изменения
['Валера', 'Саша', 'АНДРЮХА', 'Ваня'] - после изменений

В итоге, можем заключить, что список — это "контейнер", который хранит объекты в определенном порядке. Также, важно отметить, что, в отличие от строк, методы списка меняют исходный список 🙄.

Однако у списков есть кое‑что общее со строками. И это доступ к элементу по индексу и срезы. Все это работает в списках точно так же, как и в строках ❤️. Сходу закинем пример:

guests = ['Валера', 'Саша', 'АНДРЮХА', 'Ваня']

print(guests[2])
print(guests[-1])
print(guests[:2])

И вывод:

АНДРЮХА
Ваня
['Валера', 'Саша']

На этом все 🍎


#статья 📚

Кортежи (1 часть) — что это такое и чем отличаются от списков? Сегодня остановимся на этой теме 😎.


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

• Значение какого-либо его элемента уже нельзя изменить.
• Нельзя добавлять или удалять элементы 👊.

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

Вариант №1 с использованием встроенной функции "tuple()" 🫡:

# Ничего не передаем в функцию tuple()
tuple_1 = tuple()
print("Кортеж №1:", tuple_1)

# Передаем в функцию tuple() список
spisok = [ 1, 2, 3, 4, 5 ] 
tuple_2 = tuple(spisok)
print("Кортеж №2:", tuple_2)

# Передаем в функцию tuple() строку
stroka = "chupappi" 
tuple_3 = tuple(stroka)
print("Кортеж №3:", tuple_3)

Вывод программы будет следующим:

Кортеж №1: ()
Кортеж №2: (1, 2, 3, 4, 5)
Кортеж №3: ('c', 'h', 'u', 'p', 'a', 'p', 'p', 'i')

Вариант №2, в котором нужно просто перечислить объекты через запятую 1️⃣:

# Пример кортежа с одним элементом
tuple_1 = ('lonely',)
print("Кортеж №1:", tuple_1)

# Пример кортежа с несколькими элементами
tuple_2 = ('Все','на','месте','спортсмены?')
print("Кортеж №2:", tuple_2)

Вывод программы соответственно:

Кортеж №1: ('lonely',)
Кортеж №2: ('Все', 'на', 'месте', 'спортсмены?')

Если вам мозолит глаза запятая, которая стоит в примере кортежа с одним элементом (Вариант №2) — придется смириться 😭, так как таким образом Python отличает кортеж от числа в скобках (скобках, которые в этом случае будут определять порядок выполнения операций 😮‍💨).


Теперь проговорим про то, как получать элементы кортежа. Спойлер: все также, по индексу элемента, как и со списками (про них писал в посте выше 😄). К тому же, отметим, что можно провести проверку наличия или отсутствия элемента в кортеже с помощью ключевых слов "in" и "not in", пример будет ниже (с помощью этих ключевых слов также можно проверять наличие или отсутствие элементов в списках, но про это, в посте выше — я не писал ☹️).

tuple_1 = ('Антон','Ваня','Миша','Рома')

# тестим in
print('Миша' in tuple_1)
print('Андрей' in tuple_1)

# тестим not in
print('Миша' not in tuple_1)
print('Андрей' not in tuple_1)

Вывод программы будет ☕️ :

True ('Миша' есть в кортеже → да)
False ('Андрей' есть в кортеже → нет)
False ('Миша' не в кортеже → нет)
True ('Андрей' не в кортеже → да)

Что-то много слов получается, поэтому вторую часть закину следующим постом, надеюсь, что не ночью, как в этот раз ✨.


#статья 📚

Давайте уже добьем историю с кортежами, поэтому вот вторая часть по ним 💪.

В прошлом посте мы поговорили про то, как задавать кортежи, обращаться к элементам кортежей и про ключевые слова "in", "not in". Ниже предлагаю затронуть сложение (ну или конкатенацию, как вам больше нравится 😄 ) и итерирование (ну или поэлементное перечисление, как вам больше нравится 😄 ). Поехали!


Сложение "+". При помощи оператора сложения можно соединять друг с другом две одинаковые структуры данных. Ниже сразу закинем пример с кортежами ☕️:

# сложим два кортежа и выведем их

tuple_1 = ('Привет', 'я', 'Мален')
tuple_2 = ('Да', 'Мален', 'это', 'имя')

summarny_tuple = tuple_1 + tuple_2

print(summarny_tuple)

Вывод программы будет таким:

('Привет', 'я', 'Мален', 'Да', 'Мален', 'это', 'имя')

Итерирование. Кортежи (списки и строки, кстати, тоже, но я уверен, что вы знаете это 😘 ) поддерживают итерирование, то есть к каждому их элементу можно получить доступ через цикл, например, "while", "for". Каждый элемент в итерируемом объекте, как мы уже знаем, имеет свой порядковый индекс 1️⃣. Рассмотрим сразу пример, в котором в цикле "for" перечислим элементы и выведем их порядковые номера:

colors = ('Красный', 'Зеленый', 'Синий', 'Оранжевый', 'Черный', 'Белый')

for element in colors:
    print('Элемент:', element)
    print('Индекс:', colors.index(element))
    print('\n')

Скомпилируем код и получим:

Элемент: Красный
Индекс: 0


Элемент: Зеленый
Индекс: 1


Элемент: Синий
Индекс: 2


Элемент: Оранжевый
Индекс: 3


Элемент: Черный
Индекс: 4


Элемент: Белый
Индекс: 5

Быстренько разберем код выше с циклом "for":

• В строке №1 задаем наш «цветной» кортеж.

• В строке №2 создаем цикл " for ", в котором проходим по всем элементам нашего кортежа.

• В строке №3 выводим элемент с помощью функции " print() ".

• В строке №4 выводим индекс элемента используя метод " .index() ".

• В строке №5 Добавляем отступ для того, что бы вывод программы был покрасивее (чисто на мой взгляд ✨ ).

Подытожим, цикл "for", например, можно использовать, чтобы определять инструкции, которые будут выполняться один раз для каждого элемента в итерируемом объекте, и с помощью таких инструкций вы можете получать доступ ко всем этим элементам и осуществлять операции с ними ☕️.


Также, вам может стать интересно, зачем же использовать кортежи, которые неизменяемы (про это в прошлом посте ✍️), если есть списки?

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


На этом можно будет закончить 🤫.


#статья 📚

По спискам прошлись, по кортежам прошлись, но кое-что еще осталось 🤫. Заключительный "персонаж" нашей троицы - словарь 😄.

Сегодня предлагаю раскидать про него, ну или по них 💡.

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

Словарь - {"Какой-то ключ" : "Какое-то значение"}

Сразу предлагаю накидать несколько фактов о словарях (как будто они прислали + кому-то в директ. Кто понял, тот понял 😄 ):

• Связывание ключа и значения c помощью словаря называется отображением.

• Результатом отображения будет пара: ключ-значение.

• По определенному ключу можно найти соответствующее значение, однако по значению соответствующий ключ искать нельзя ☹️.

• Словари изменяемы (как и списки),то есть в них можно добавлять новые пары ключ-значение 😮‍💨.

• В словаре может быть несколько пар ключ-значение 1️⃣.

• У одного ключа может быть несколько значений, но не наоборот. То есть ключ — уникален, а значение — нет 😭.

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

• Когда нужно хранить свойства определенного объекта. Тогда ключом будет сам объект, а значением — его свойства 🍔.

• Когда нужно быстро получить значение по определенному ключу. Предположим, вы создали словарь, в котором ключ - имя вашего друга, а значение — его телефон. В итоге, можно по имени быстро получить необходимый номер 📞.

• Когда нужно считать количество определенных слов в тексте (да-да, такое иногда реально нужно ☹️ ). В таком случае, результаты подсчета удобно представить в виде словаря, в котором ключ — это определенное слово, а значение — количество его появлений в тексте.

Теперь пришла очередь примеров ✍️. Давайте создадим классическую телефонную книжку в виде словаря c одним номером, а затем добавим в нее еще парочку номеров, плюс выведем какое-нибудь значение (в примере — это номер) по ключу (в примере — это имя):

# создаем нашу телефонную книгу
TypicalPhoneBook = {
    'Братанчик': '+71234567890'
}

# выводим телефонную книгу после создания
print('Создали телефонную книгу:', TypicalPhoneBook)
print('\n')

# добавляем в нее пару номеров
TypicalPhoneBook['Лютый перец'] = '+79876543210'
TypicalPhoneBook['Скам, не брать'] = '+70000000000'

# выводим телефонную книгу после добавления номеров
print('Добавили в нее пару номеров:', TypicalPhoneBook)
print('\n')

# выводим значение по ключу: 
print('Номер телефона братанчика:', TypicalPhoneBook['Братанчик'])
print('\n')

Вывод такой программы представлен ниже:

Создали телефонную книгу: {'Братанчик': '+71234567890'}

Добавили в нее пару номеров: {'Братанчик': '+71234567890', 'Лютый перец': '+79876543210', 'Скам, не брать': '+70000000000'}

Номер телефона братанчика: +71234567890

Кратенько подытожим:

1. Если в нашем словаре одна пара ключ-значение, то после нее не нужно ставить "," как в случае с кортежами ☕️. (P.S. — про кортежи можно почитать в посте выше)

2. Как только вы создали словарь, можно добавлять в него пары ключ-значение, используя синтаксис, который имеет следующий общий вид: "имя_словаря[ключ] = значение" ✨.

3. Чтобы найти значение при помощи ключа можно использовать синтаксис с видом: " имя_словаря[ключ] " ❤️.


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


#статья 📚

Методы словарей в Python, сегодня рассмотрим их. Поехали ☕️!


Словари имеют много разных методов для упрощения работы с ними и решения повседневных задач 🤫. Для начала посмотрим, как работают методы:

• ".keys()" — возвращает список ключей словаря.

• ".values()" — возвращает список значений словаря.

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

# создаем словарь
antony = {
    'Имя': 'Антон',
    'Возраст' : 35,
    'Работа' : 'Водитель',
    'Прическа' : 'Лысый :)'
}

# метод .keys()
print('Список ключей словаря:', antony.keys())

# метод .values()
print('Список значений словаря:', antony.values())

Вывод программы будет соответствующий 🍎:

Список ключей словаря: dict_keys(['Имя', 'Возраст', 'Работа', 'Прическа'])

Список значений словаря: dict_values(['Антон', 35, 'Водитель', 'Лысый :)'])

Далее, поговорим про более интересные методы (чисто на мой взгляд ❤️):

• ".get(ключ, указанное в методе значение)" — возвращает значение по ключу, если этот ключ существует или, если его не существует — возвращает указанное в самом методе значение 😭.

• ".update(другой словарь)" — производит дополнение одного словаря другим, добавляя (если ключа нет) или перезаписывая (если ключ есть) значения ключей исходного словаря 🤯.

• ".copy()" — создает поверхностную копию словаря 1️⃣.

• ".pop(ключ, указанное в методе значение)" — метод вернет значение ключа, который указывается в методе, а также удалит его из словаря. Если ключ не найден, то будет возвращено значение по умолчанию, которое можно также указать в методе 👨‍💻.

• ".popitem()" — удаляет из словаря последний добавленный элемент и возвращает удаляемый элемент в виде кортежа: "(ключ, значение)" ☹️.

• ".clear()" — просто удаляет все элементы из словаря ✨.

Знаю, что получилось очень много текста, поэтому давайте попробуем разобрать все эти методы на одном большом примере 😮‍💨:

# создаем словари
n_v1 = {'список' : 'v1', 'один' : 1, 'два' : 2, 'три' : 3}
n_v2 = {'список' : 'v2', 'пять' : 5}

# метод .get()
print(n_v1.get('один'))
print(n_v1.get('ноль', 'нуля нет'))
print('\n')

# метод .update()
n_v1.update(n_v2)
print(n_v1)
print('\n')

# метод .copy()
new = n_v1.copy()
print(new)
print('\n')

# метод .pop()
print(n_v1.pop('один'))
print(n_v1)
print(n_v1.pop('семь', 'семи нет'))
print('\n')

# метод .popitem()
print(n_v1.popitem())
print(n_v1)
print('\n')

# метод .clear()
n_v1.clear()
print(n_v1)

Вывод программы выше будет соответствующим, в скобках — небольшое пояснение 😏:

1 (вернул значение по ключу 'один')
нуля нет (ключа 'ноль' нет, поэтому вернул 'нуля нет')


{'список': 'v2', 'один': 1, 'два': 2, 'три': 3, 'пять': 5} (обновленный словарь n_v1)


{'список': 'v2', 'один': 1, 'два': 2, 'три': 3, 'пять': 5} (словарь new - копия обновленного словаря n_v1)


1 (вернул значение элемента удаленного по ключу 'один')
{'список': 'v2', 'два': 2, 'три': 3, 'пять': 5} (словарь после удаления)
семи нет (ключ 'семь' отсутствует в словаре, поэтому вернул 'семи нет')


('пять', 5) (вернул удаленный элемент в виде кортежа)
{'список': 'v2', 'два': 2, 'три': 3} (словарь без последнего добавленного в него элемента)


{} (вывели очищенный от всех элементов словарь)

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


#статья 📚

Предлагаю сегодня поговорить про что-то мнимое... Например, про мнимую единицу 💀.


Что такое эта ваша мнимая единица и зачем она вообще нужна, если является мнимой 🤌?


Давайте по порядку. Мнимая единица обозначается буквой i и является числом, квадрат которого равен -1 🤫. То есть:

i² = -1

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


Далее, предлагаю обозначить: зачем мнимая единица нужна в реальной жизни 😏?

Может показаться, что такие "вымышленные" числа не имеют практического применения. Однако, комплексные числа (числа, состоящие из действительной и мнимой частей 1️⃣), в которых используется мнимая единица, нашли широкое применение в различных областях науки и техники:

• Электротехника:
Комплексные числа позволяют описывать переменный ток, сопротивление, емкость и индуктивность электрических цепей. Это упрощает расчеты и анализ электрических схем 😎.

• Физика:
Мнимые числа используются в квантовой механике, теории относительности и других областях физики для описания волновых процессов, квантовых состояний и других явлений ✨.

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

• Обработка сигналов:
Комплексные числа широко используются в обработке звуковых, радио и других сигналов 😏.

• Аэродинамика:
Комплексные числа применяются для моделирования обтекания тел потоком жидкости или газа 🥶.


Теперь давайте соберем все очевидные плюсы, которые появились благодаря нашей мнимой единице и, соответственно, комплексным числам 😄:

• Мнимые числа объединяют различные области математики, создавая единую и мощную систему для решения задач 💡.

• Комплексные числа позволяют упростить многие математические операции и получить более компактные и элегантные решения ❤️.

• Мнимые числа открывают новые возможности для моделирования и анализа различных явлений в природе и технике 😏.

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


От теории перейдем к практике и опишем некоторые основные тождества, которые включают в себя i:


• Степени мнимой единицы:

◦ i¹ = i,
◦ i² = i * i = -1,
◦ i³ = i² * i = -i,
◦ i⁴ = i² * i² = 1,

И так далее, степени мнимой единицы циклически повторяются с периодом равным 4 🍎.


• Сопряженные комплексные числа:

◦ Если z = a + b * i, то сопряженное число z* = a - b * i.
◦ Произведение z * z* = (a + b * i) * (a - b * i) = a² + b² (всегда действительное число 😮‍💨).


• Тождество Эйлера:

◦ e^(iπ) + 1 = 0, где:
◦ e – основание натурального логарифма;
◦ π – число пи;
◦ i – мнимая единица,

Данное тождество связывает пять фундаментальных математических констант и считается одним из самых известных и красивых в математике ✨.


• Формула Эйлера:

◦ e^(ix) = cos(x) + i * sin(x),

С помощью данной формулы устанавливается связь между экспоненциальной функцией и тригонометрическими функциями 👨‍💻.


Думаю, что на этом можно закончить, чтобы не подводить итоговый итог 😄. Вот такой вот классический ночной пост ☔️.


#статья 📚

Предлагаю написать небольшой обзор на множества в этот последний день лета 🩸

Множество — это одно из основных понятий математики. Оно представляет собой совокупность объектов, которые рассматриваются как единое целое 🧘. Эти объекты обычно называются элементами множества ❤️.


Теперь, предлагаю остановиться на основных характеристиках множеств:

• Одна из основных характеристик — это сами элементы множества 😄. Например, множество всех целых чисел, множество всех автомобилей марки BMW , множество всех слов в русском языке.

• Вторая основная характеристика множеств — это условие их равенства. Если говорить простым языком: два множества считаются равными, если они содержат в точности одинаковые элементы 😎.

• Третья основная характеристика множеств, на мой взгляд, это пустое множество. Множество пустое, если не содержит в себе ни одного элемента 😭.

Также, можем кратко описать основные операции над множествами, поехали ✨:


1. Объединение множеств.

Объединением множеств А и B является множество, которое состоит из всех элементов множеств А и В. Если записывать кратко 1️⃣:

A∪B={x | x∈A или x∈B}, где x — это элемент.

2. Пересечение множеств.

Пересечением множеств А и В является множество, состоящее из элементов, которые одновременно принадлежат и множеству А и множеству В. Запишем кратко ☕️:

A∩B={x | x∈A и x∈B}, где х — это элемент.

3. Разность множеств.

Разностью множеств А и В является множество, элементы которого принадлежат множеству А, но не принадлежат множеству В. По классике, запишем кратко 😮‍💨:

A \ B={x | x∈A и x∉B}, где x — это элемент.

4. Симметрическая разность.

Симметрической разностью множеств А и B является множество, элементы которого принадлежат либо множеству А, либо множеству В, но не обоим одновременно. Два варианта краткой записи 🤯:

• A Δ B = (A \ B) ∪ (B \ A) — используем ранее определенные операции.

• A Δ B = (A∪B) \ (A∩B) — используем ранее определенные операции.

5. Дополнение множества.

Допустим, что у нас есть универсальное множество В. Множество А является подмножеством В, т.е. "входит" в него. В таком случае, дополнением множества А является множество элементов, которые принадлежат множеству В, но не принадлежат множеству А. Давайте запишем кратко 💪:

А* = B \ A = {x | x∈B и x∉A}, где x — это элемент.
(кстати, отсюда следует, что A∪A* = B)

6. Декартово произведение.

Декартовым произведением двух множеств является множество всех возможных упорядоченных пар элементов из исходных множеств. Первый элемент пары принадлежит первому множеству, второй — второму ☹️. Закинем краткую запись определения ✍️:

A × B = { (a,b) | a∈A и b∈B }, где (a,b) — пара элементов.

После того, как мы с вами пробежались по основным характеристикам и операциям с множествами, предлагаю описать основные (на мой взгляд) типы множеств 👨‍💻:

• Конечные и бесконечные.
Множество может содержать как конечное, так и бесконечное количество элементов 😏.

• Упорядоченные и неупорядоченные.
В упорядоченных множествах элементы имеют определённый порядок (пронумерованы), в неупорядоченных — нет (перечислены как попало) 😏.

• Универсальное.
Это множество, которое является базовым для всех остальных. Например, при исследованиях человеческой популяции, универсальное множество — это множество всех людей в мире 🤫.

• Единичное и пустое.
Тут все просто: единичное — множество с одним элементом, пустое — множество без элементов 👊.

Думаю, что на сегодня можно закончить 👌.


#статья 📚

Всем привет, что-то давно не было постов — пора это исправить ☕️!


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

• Математика как язык физики 😎.

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

• Математические модели 💀.

Физики используют математические модели для описания и предсказания поведения физических систем. Например, уравнения Максвелла описывают электромагнитные поля, а уравнения Ньютона — движение тел. Эти модели позволяют проводить расчеты и делать предсказания, которые можно проверить экспериментально 👍.

• Развитие новых математических методов ✍️.

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

• Взаимное влияние ✨.

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

В качестве примера предлагаю описать три закона Ньютона 🤗:


• Первый закон Ньютона (закон инерции) 😍.
Он утверждает, что тело сохраняет состояние покоя или равномерного прямолинейного движения, если на него не действуют внешние силы. Математически это можно выразить следующим образом:

∑F = 0 ⇒ V = const, где:

• ∑F — сумма всех сил, действующих на тело;

• V — скорость тела.

Сходу простой пример:

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


• Второй закон Ньютона (закон ускорения) 1️⃣.
Второй закон Ньютона описывает, как сила влияет на движение тела. Он утверждает, что ускорение тела прямо пропорционально результирующей силе, действующей на него, и обратно пропорционально его массе:

a = F / m, где:

• F — результирующая сила, которая действует на тело;

• m — масса тела;

• a — ускорение тела;

• Сила и ускорение — являются векторными величинами, их направления всегда совпадают.

Приведем небольшой пример:

Если на тело массой 5 кг действует сила 10 Н, то его ускорение можно найти так: a = F / m = 10 Н / 5 кг = 2 м/с^2.


• Третий закон Ньютона (закон действия и противодействия) 😏.
Третий закон Ньютона утверждает, что для каждой силы, действующей на тело, существует равная по величине и противоположная по направлению сила, действующая на другое тело. Запишем формулу, которая описывает вышесказанное:

F₁₂ = – F₂₁, где:

• F₁₂ — сила, действующая на первое тело со стороны второго;

• F₂₁ — сила, действующая на второе тело со стороны первого.

Наглядный пример:

Когда вы толкаете стену, стена толкает вас с такой же силой, но в противоположном направлении. Если вы прикладываете силу 100 Н к стене, стена прикладывает к вам силу -100 Н 😄.


В итоге, мы на простом примере, увидели, что математика предоставляет инструменты и язык для описания физических явлений. Благодаря этому, физика стимулирует развитие новых математических методов. Эта взаимосвязь позволяет более глубоко разбираться в природных явлениях и делать более точные предсказания о поведении физических систем. На этом сегодня и закончим 😏.


#статья 📚

Ребята, всем привет ❤️!


Решил написать небольшой пост с анонсом того, что (может быть) будет с данным каналом в дальнейшем 😎.


Предлагаю к тому, что есть — добавить посты на следующие темы:

• Физика ✨.

• Языки программирования помимо Python, например, тот же SQL ☕️.

• Как наука может пригодится в реальной работе 🤗.

В связи с этим можно сделать ребрендинг и перейти к названию «Math and Code» ✅


Также, если у вас есть желание, можете поддержать канал голосом, это поможет чуть больше заморачиваться с оформлением, а это мы любим 😄. Вот ссылка: https://t.me/boost?c=2187172722


Ниже будет небольшой опрос 😠.


#лайф 🤝🏻

Сегодня можем коснуться такой здравой темы, как функции в Python 😮‍💨!


Функции в Python, да и вообще в любом языке программирования, можно понимать как список последовательных инструкций, которые могут принимать входящие данные, выполнять указания и возвращать выходящие данные 1️⃣.

Чтобы понять на пальцах, как устроена функция — можно представить следующую картину:

• Представьте, что вы принесли небольшое бревно и положили его на конвейер ⚙️.

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

• В итоге, в конце конвейера вас будут ждать уже нарезанные и отполированные доски, но только в том случае, если конвейер работает правильно 😄.

Теперь, предлагаю обсудить зачем вообще нужны функции и что можно с ними делать 🤔?

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

Вызвать функцию — значит передать ей входные данные, необходимые для выполнения и возвращения результата ✍️.

Общий синтаксис функции опишем сразу на простом примере ✨:

#Определяем функцию
def proizvedenie(a, b):
    
    #Начало тела функции
    c = a * b
    #Конец тела функции
    
    #Значение, которое возвращаем
    return c

Чтобы вызвать нашу функцию из примера выше, напишем следующее:

print(proizvedenie(5,7))
print(proizvedenie(7,8))
print(proizvedenie(9,9))

После компиляции, вывод будет следующий:

35
56
81

Разберем чуть поподробнее, что именно мы сделали выше 👍:

1. Написали функцию, которая на вход принимает значения двух переменных "а" и "b".

2. Затем умножает значение переменной "а" на значение переменной "b" и записывает результат в переменную "с".

3. В итоге, функция возвращает значение переменной "с".

4. Далее, вызываем нашу функцию передавая ей два конкретных значения через запятую.

5. Чтобы сразу отобразить результат, который наша функция возвращает обернем ее в "print()".

6. Повторим пункты №4 и №5 еще два раза, для наглядности 💪.

В этот раз получилось так, что мы начали с практики следовательно закончить нужно теорией (для закрепления материала ☹️), поэтому напишем несколько основных фактов про функции:

• Ключевое слово "def" сообщает Python, что вы определяете функцию.

• Наименование функции должно задаваться по тому же принципу, что и наименования переменных (без заглавных букв, с разделением слов с помощью нижнего подчеркивания "_" 🧐).

• После того, как вы задали наименование функции, укажите после него круглые скобки с необходимыми аргументами. После скобок всегда ставится двоеточие, а новая строка начинается с отступа в четыре пробела. Любой код с отступом в четыре пробела после двоеточия является телом функции 🤫.

• Ключевое слово "return" используется для определения значения, которое функция будет возвращать при вызове 📞.

• Результат, который возвращает функция при вызове, можно сохранить в переменной и использовать при необходимости 🤪.

• У функции может быть один или несколько аргументов или же аргументы могут полностью отсутствовать. Чтобы определить функцию без аргументов, нужно оставить круглые скобки после наименования функции — пустыми.


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

Думаю, что на этом можно остановится, чтобы не перегрузиться 😭!


#статья 📚

Всем привет 😽!

Наконец-то я закрыл сессию в аспирантуре, поэтому пора прервать тишину в нашем канале 🔫🙂🔫.

Сегодня предлагаю начать серию постов про такой язык программирования, как SQL (Structured Query Language). Поехали 🚘!


SQL — это язык запросов, который используется для работы с реляционными базами данных. С помощью него можно манипулировать с данными, а именно извлекать, обновлять, удалять и сортировать их 😏.

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

Давайте попробуем сравнить SQL с чем-то понятным и знакомым, например, с фильтрами в интернет-магазине. Представьте, что вы ищете кеды Vans с "олд-скул" платформой, черного цвета и хотите уложиться в определённую сумму ☕️. Вместо того чтобы просматривать все доступные кеды и искать среди них ваш вариант, можно использовать фильтры по модели, цвету и цене. Вот как раз эти самые фильтры работают благодаря SQL, который помогает быстро находить нужные данные (например, конкретную модель обуви) среди большого объёма информации (например, среди всей продукции, которую производит обувная компания) ❤️.


После этого, стоит отметить, что SQL работает с реляционными базами данных. Такие базы данных имеют структуру в виде таблиц, которые состоят из строк и столбцов 😵. Если таблиц несколько, то они взаимосвязаны между собой с помощью первичных и внешних ключей — это позволяет устанавливать "отношения" между разными наборами данных 😎.

А вот с NoSQL-базами данных наш язык особо не дружит, так как NoSQL-базы данных предназначены для работы с большими объемами информации и часто используются в приложениях, от которых нужна высокая производительность и возможность масштабируемости 🏋️‍♂️.

Если опять сравнить эти два варианта баз данных с чем-то, то в голову приходит следующее ✍️:

• Реляционные базы данных можно представить в виде организованного хранилища файлов, в котором каждый файл находится в определённом ящике с меткой. Благодаря этому можно быстро найти то, что нужно 1️⃣.

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

Теперь немного практики 😄. В качестве примера функций, которые можно использовать в языке SQL, опишем функции для сбора сводной информации (возьмем самые базовые):

• COUNT() — возвращает количество строк в таблице (наборе данных). Формально записывается так:

 SELECT COUNT(*) FROM таблица;

• SUM() — возвращает сумму значений из указанного столбца таблицы. Формально записывается:

 SELECT SUM(столбец) FROM таблица;

• AVG() — возвращает среднее значение в указанном столбце таблицы. Формально:

 SELECT AVG(столбец) FROM таблица;

• MIN() — возвращает минимальное значение из указанного столбца таблицы. Обычно записывается как:

 SELECT MIN(столбец) FROM таблица;

• MAX() — возвращает максимальное значение из указанного столбца таблицы. Обычно записывается как:

 SELECT MAX(столбец) FROM таблица;

Думаю, что можно на этом закончить, так как пост получился не загруженным, а это всегда хорошо. Скоро продолжим 🥷!


#статья 📚