Python

# Проверка версии Python
python --version

# Что вы должны увидеть:
# Python 3.11.x (или Python 3.12.x)

# Если видите это - отлично! Python установлен правильно!

# Верификация успешной установки в терминале macOS
python3 --version
# Ожидаемый результат: Python 3.11.x

# Проверка версии Python
python3 --version

# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip

# Fedora
sudo dnf install python3 python3-pip

# Arch Linux
sudo pacman -S python python-pip

# В командной строке введите:
python

# Что вы увидите:
# Python 3.11.x (дата и время)
# Type "help", "copyright" и т.д.
# >>>

# Три стрелочки >>> означают: "Я слушаю, вводи команду!"

# Команда 1: Приветствие
>>> print("Привет, мир!")
Привет, мир!

# Поздравляю! Вы только что написали свою первую программу на Python!

# Команда 2: Простая математика
>>> 2 + 3
5

# Команда 3: Посложнее
>>> 10 * 5 + 2
52

# Команда 4: Работа с текстом
>>> "Привет, " + "Python!"
'Привет, Python!'

# Команда 5: Выход из интерактивного режима
>>> exit()
# Или нажмите Ctrl + Z и Enter (Windows) / Ctrl + D (Mac/Linux)

print("Привет, мир!")
print("Это моя первая программа на Python!")
print("Я научусь программировать!")

# В командной строке введите (и нажмите Enter):
cd Desktop

# cd = "change directory" (сменить папку)
# Теперь вы находитесь на Рабочем столе

# Введите эту команду:
python hello.py

# Что вы должны увидеть:
# Привет, мир!
# Это моя первая программа на Python!
# Я научусь программировать!

# ПОЗДРАВЛЯЮ! Вы создали и запустили настоящую программу!

# Правильное использование отступов (так нужно делать!)
if True:  # Это главная команда (пока не важно что она значит)
    print("Эта строка с отступом — она в группе")  # 4 пробела в начале
    print("Эта тоже с отступом — тоже в группе")   # 4 пробела в начале
print("А эта БЕЗ отступа — она отдельно")          # Без пробелов в начале

# Неправильное использование отступов (так делать НЕЛЬЗЯ!)
if True:  # Главная команда
print("Ошибка! Нет отступа, хотя должен быть")  # Python выдаст ошибку IndentationError

# Комментарий начинается с символа решётки #
# Python видит # и игнорирует всё, что после неё до конца строки
# Это удобно для пояснений в коде!

# Выведем приветствие
print("Привет, мир!")  # Комментарий можно писать и после кода в той же строке

# Вычислим сумму
result = 10 + 20  # Складываем 10 и 20, результат сохраняем в переменную result

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

print("Комментарии никак не влияют на работу программы!")  # Программа работает как обычно

# Создаем переменную name и кладем туда текст "Алексей"
# Знак = означает "положи значение справа в переменную слева"
name = "Алексей"      # Текст всегда в кавычках! Это называется "строка" (string, str)

# Создаем переменную age и кладем туда число 25
age = 25              # Число БЕЗ кавычек! Это целое число (integer, int)

# Создаем переменную height и кладем туда число с дробной частью
height = 1.85         # Число с точкой — это число с плавающей точкой (float)

# Создаем переменную is_student и кладем туда True (правда/истина)
is_student = True     # True или False — это логический тип (boolean, bool)

# Теперь выведем все значения на экран
# print() показывает, что внутри переменной
print(name)           # Покажет: Алексей
print(age)            # Покажет: 25
print(height)         # Покажет: 1.85
print(is_student)     # Покажет: True

# Можем изменить значение переменной — просто присвоим новое!
age = 26              # Теперь в age лежит 26 вместо 25
print("Обновленный возраст:", age)  # Покажет: Обновленный возраст: 26

# ПРАВИЛЬНЫЕ имена переменных (так можно делать)
user_name = "John"       # Слова разделены подчеркиванием — отлично!
age1 = 30                # Цифра в конце — можно!
age_2 = 31               # Цифра после подчеркивания — тоже можно!
_private = "Секрет"      # Начинается с подчеркивания — разрешено
firstName = "Иван"       # Большая буква в середине — работает
my_super_long_variable_name = "Длинное имя — тоже ОК"

# НЕПРАВИЛЬНЫЕ имена переменных (так делать НЕЛЬЗЯ!)
# 1name = "Ошибка"       # Начинается с цифры — Python выдаст ошибку!
# my-var = 10            # Дефис запрещен! Используйте подчеркивание: my_var
# my var = 10            # Пробел запрещен! Используйте: my_var
# if = "Ошибка"          # if — специальное слово Python, нельзя использовать!
# for = "Ошибка"         # for — тоже специальное слово!

# ВАЖНО: Это РАЗНЫЕ переменные! Python различает регистр букв
name = "Маша"            # Маленькая n
Name = "Петя"            # Большая N — это уже другая переменная!
print(name)              # Выведет: Маша
print(Name)              # Выведет: Петя

# Способ 1: Присвоить одно и то же значение нескольким переменным
x = y = z = 0             # Все три переменные получают значение 0
print(x, y, z)            # Выведет: 0 0 0
# Простыми словами: создали 3 коробки (x, y, z) и в каждую положили 0

# Способ 2: Присвоить разные значения нескольким переменным сразу
a, b, c = 1, 2, 3         # a получает 1, b получает 2, c получает 3
print(a, b, c)            # Выведет: 1 2 3
# Простыми словами: создали 3 коробки и в каждую положили своё число

# Способ 3: Обменять значения двух переменных местами
a = 10                    # a = 10
b = 20                    # b = 20
print("До обмена:", a, b) # До обмена: 10 20

a, b = b, a               # Меняем местами! a получает значение b, b получает значение a
print("После обмена:", a, b)  # После обмена: 20 10
# Это как поменять содержимое двух коробок местами — в Python это делается легко!

# Создаем переменные разных типов
number = 42             # Целое число (int) — без кавычек, без точки
pi = 3.14159            # Число с точкой (float) — для дробных чисел
name = "Python"         # Текст в кавычках (str) — строка
is_active = True        # Логическое значение (bool) — только True или False
nothing = None          # Пустое значение (None) — когда ничего нет

# Как узнать тип переменной? Используем функцию type()
print(type(number))     # Выведет:  — это целое число
print(type(pi))         # Выведет:  — число с точкой
print(type(name))       # Выведет:  — строка (текст)
print(type(is_active))  # Выведет:  — логический тип
print(type(nothing))    # Выведет:  — пустое значение

# Посмотрим на значения переменных
print(number)           # Выведет: 42
print(pi)               # Выведет: 3.14159
print(name)             # Выведет: Python
print(is_active)        # Выведет: True
print(nothing)          # Выведет: None

# Проблема: input() всегда даёт ТЕКСТ!
age_text = "25"             # Это текст "25", не число 25
# print(age_text + 5)       # ОШИБКА! Нельзя складывать текст и число!

# Решение: превратить текст в число
age_number = int(age_text)  # int() превращает текст "25" в число 25
print(age_number + 5)       # Работает! 25 + 5 = 30

# Еще пример с input()
# age = input("Ваш возраст: ")  # Пользователь вводит 20
# print(age + 1)               # ОШИБКА! age это текст "20", не число!
# Правильно:
# age = int(input("Ваш возраст: "))  # Сразу превращаем в число!
# print(age + 1)                     # 20 + 1 = 21

# Превращаем дробное число в целое
price = 19.99               # Дробное число
price_whole = int(price)    # int() отрезает всё после точки!
print(price_whole)          # Выведет: 19 (не 20! Не округляет, а просто отрезает .99)

# Превращаем число в текст (чтобы склеить с другим текстом)
count = 100                 # Число
count_text = str(count)     # str() превращает число 100 в текст "100"
message = "У вас " + count_text + " сообщений"  # Склеиваем тексты
print(message)              # Выведет: У вас 100 сообщений

# Альтернатива: можно использовать запятую в print() (проще!)
print("У вас", count, "сообщений")  # Тоже выведет: У вас 100 сообщений

# Превращаем в True/False
number1 = 1                 # Любое число кроме 0
result1 = bool(number1)     # bool() превращает в True или False
print(result1)              # Выведет: True (не ноль = True)

number2 = 0                 # Ноль
result2 = bool(number2)     # Ноль превращается в False!
print(result2)              # Выведет: False

text1 = "Привет"            # Непустой текст
print(bool(text1))          # Выведет: True (есть текст = True)

text2 = ""                  # Пустой текст (пустые кавычки)
print(bool(text2))          # Выведет: False (пусто = False)

# Самое простое использование — выводим текст
print("Привет, мир!")       # Выведет на экран: Привет, мир!

# Выводим число
print(42)                   # Выведет: 42

# Выводим несколько вещей сразу (через запятую)
name = "Анна"               # Создаем переменную с именем
age = 28                    # Создаем переменную с возрастом
print("Имя:", name, "Возраст:", age)  # Выведет: Имя: Анна Возраст: 28
# Python автоматически ставит пробелы между элементами!

# Выводим только переменные
print(name, age)            # Выведет: Анна 28

# Пустой print() выводит пустую строку (перенос строки)
print("Строка 1")
print()                     # Пустая строка
print("Строка 3")
# Выведет:
# Строка 1
# (пустая строка)
# Строка 3

# F-строки — удобный способ вставить переменные в текст
name = "Мария"
age = 25
print(f"Привет, {name}! Вам {age} лет.")  
# f перед кавычками означает "форматированная строка"
# {name} заменится на значение переменной name
# Выведет: Привет, Мария! Вам 25 лет.

# Можно менять разделитель между элементами
# По умолчанию разделитель — пробел
# sep= позволяет изменить это
print("Яблоко", "Банан", "Апельсин")  # Выведет: Яблоко Банан Апельсин (пробелы)
print("Яблоко", "Банан", "Апельсин", sep=" | ")  # Выведет: Яблоко | Банан | Апельсин

# Можно изменить что будет в конце строки
# По умолчанию print() в конце переходит на новую строку
# end= позволяет изменить это
print("Строка 1")           # После вывода переходит на новую строку
print("Строка 2")           # Поэтому это выведется ниже
# Результат:
# Строка 1
# Строка 2

print("Строка 1", end=" --> ")  # Вместо перехода на новую строку поставит " --> "
print("Строка 2")               # И это выведется на той же строке!
# Результат: Строка 1 --> Строка 2

# Запрашиваем имя у пользователя
name = input("Введите ваше имя: ")  
# Программа показывает вопрос: "Введите ваше имя: "
# Программа ждет, пока пользователь введет ответ и нажмет Enter
# Ответ сохраняется в переменную name

# Теперь используем то, что пользователь ввел
print("Здравствуйте,", name, "!")    # Если ввели "Мария", выведет: Здравствуйте, Мария !

# Еще пример
favorite_color = input("Какой ваш любимый цвет? ")  # Спрашиваем цвет
print("Отличный выбор!", favorite_color, "— красивый цвет!")  # Используем ответ

# Проблема: input() всегда дает текст!
age = input("Введите ваш возраст: ")  
# Пользователь вводит: 20
# Но age теперь содержит ТЕКСТ "20", а не ЧИСЛО 20!

print(type(age))       # Проверим тип — выведет:  (строка, текст!)

# Попробуем прибавить 1 к возрасту
# next_year = age + 1  # ОШИБКА! Нельзя сложить текст "20" и число 1

# Правильное решение: сначала превратить текст в число!
age_number = int(age)          # Превращаем текст "20" в число 20
next_year = age_number + 1     # Теперь можно складывать: 20 + 1 = 21
print("В следующем году вам будет", next_year, "лет")  # Выведет: В следующем году вам будет 21 лет

# Часто делают так — сразу превращают в число:
age = int(input("Ваш возраст: "))  # input() дает текст, int() сразу превращает в число
print("Через 5 лет вам будет", age + 5, "лет")  # Теперь age это число, можно складывать!

# Способ 1: одинарные кавычки '
s1 = 'Привет'        # Текст в одинарных кавычках
print(s1)            # Выведет: Привет

# Способ 2: двойные кавычки "
s2 = "Мир"           # Текст в двойных кавычках (работает так же, как одинарные)
print(s2)            # Выведет: Мир

# Оба способа одинаковы, но двойные удобны когда в тексте есть апостроф:
s4 = "It's Python"   # Апостроф внутри двойных кавычек — работает!
s5 = 'Он сказал "Привет"'  # Кавычки внутри одинарных — тоже работает!

# Способ 3: тройные кавычки ''' или """ — для длинного текста на несколько строк
s3 = '''Это текст
на нескольких
строках'''           # Можно писать текст с переносами строк!
print(s3)
# Выведет:
# Это текст
# на нескольких
# строках

# Операция 1: Склеивание строк (конкатенация)
s1 = "Привет"
s2 = "Мир"
result = s1 + ' ' + s2   # Знак + склеивает строки
print(result)            # Выведет: Привет Мир

# Операция 2: Повторение строки
s1 = "Привет"
print(s1 * 3)            # Повторить строку 3 раза
# Выведет: ПриветПриветПривет

print("=" * 20)          # Полезно для линий!
# Выведет: ====================

# Операция 3: Узнать длину строки (сколько символов)
s1 = "Привет"
length = len(s1)         # len() считает количество символов
print(length)            # Выведет: 6 (6 букв в слове "Привет")

# Операция 4: Получить один символ из строки (по номеру позиции)
s1 = "Привет"
print(s1[0])             # Первый символ (нумерация с 0!) — выведет: П
print(s1[1])             # Второй символ — выведет: р
print(s1[5])             # Шестой символ — выведет: т

# Можно с конца! -1 это последний символ
print(s1[-1])            # Последний символ — выведет: т
print(s1[-2])            # Предпоследний — выведет: е

# Операция 5: Получить часть строки (срез)
s1 = "Привет"
print(s1[1:4])           # Символы с позиции 1 по 3 (4 не включается!) — выведет: рив
print(s1[:3])            # От начала до позиции 2 — выведет: При
print(s1[3:])            # От позиции 3 до конца — выведет: вет

# Запомните: Python считает с 0, и конечная позиция не включается!
# "Привет"
#  012345  <- позиции
#  П р и в е т

text = "Python - мощный язык программирования"

# Метод 1: upper() — сделать ВСЕ буквы большими (заглавными)
print(text.upper())      # Выведет: PYTHON - МОЩНЫЙ ЯЗЫК ПРОГРАММИРОВАНИЯ

# Метод 2: lower() — сделать все буквы маленькими (строчными)
print(text.lower())      # Выведет: python - мощный язык программирования

# Метод 3: replace() — заменить часть текста на другую
new_text = text.replace("мощный", "элегантный")  # Заменить "мощный" на "элегантный"
print(new_text)          # Выведет: Python - элегантный язык программирования

# Метод 4: split() — разбить текст на отдельные слова
words = text.split()     # Разделить по пробелам
print(words)             # Выведет: ['Python', '-', 'мощный', 'язык', 'программирования']
# Получится список (list) слов — изучим списки позже!

# Метод 5: strip() — убрать лишние пробелы в начале и конце
messy = "   много пробелов   "
clean = messy.strip()    # Убрать пробелы по краям
print(clean)             # Выведет: много пробелов (без пробелов по краям!)

# Метод 6: find() — найти позицию слова в тексте
position = text.find("язык")    # На какой позиции начинается слово "язык"?
print(position)                 # Выведет: 17 (начинается с 17-й позиции)

# Если слова нет, вернет -1
position2 = text.find("Java")   # Ищем "Java" (такого слова нет)
print(position2)                # Выведет: -1 (не найдено)

# Метод 7: Проверить, есть ли слово в тексте (не метод, а оператор in)
print("язык" in text)    # Есть ли слово "язык" в тексте?
# Выведет: True (да, есть!)

print("Java" in text)    # Есть ли слово "Java" в тексте?
# Выведет: False (нет, нету!)

# Метод 8: count() — посчитать, сколько раз встречается буква или слово
print(text.count("м"))   # Сколько букв "м" в тексте?
# Выведет: 2 (буква "м" встречается 2 раза)

# Создаем логические переменные
is_active = True         # Переменная хранит значение "правда"
is_completed = False     # Переменная хранит значение "ложь"

print(is_active)         # Выведет: True
print(is_completed)      # Выведет: False

# Важно: пишется с БОЛЬШОЙ буквы! True и False, а не true и false

is_active = True
is_completed = False

# Операция 1: and (И) — оба условия должны быть True
result = is_active and is_completed   # True И False = False
print(result)                         # Выведет: False
# Простыми словами: "Активно И Завершено?" → "Да И Нет?" = Нет

# Операция 2: or (ИЛИ) — хотя бы одно условие должно быть True
result = is_active or is_completed    # True ИЛИ False = True
print(result)                         # Выведет: True
# Простыми словами: "Активно ИЛИ Завершено?" → "Да ИЛИ Нет?" = Да (хватит одного "Да")

# Операция 3: not (НЕ) — переворачивает значение
result = not is_active                # НЕ True = False
print(result)                         # Выведет: False
# Простыми словами: "НЕ Активно?" → "НЕ Да?" = Нет

# Сравниваем числа
x = 10
y = 5

# Больше >
print(x > y)     # 10 больше 5? Да! — Выведет: True

# Меньше <
print(x < y)     # 10 меньше 5? Нет! — Выведет: False

# Равно == (два знака равно!)
print(x == y)    # 10 равно 5? Нет! — Выведет: False

# Не равно !=
print(x != y)    # 10 не равно 5? Да! — Выведет: True

# Больше или равно >=
print(x >= 10)   # 10 больше или равно 10? Да (равно)! — Выведет: True

# Меньше или равно <=
print(y <= 10)   # 5 меньше или равно 10? Да! — Выведет: True

# Любое значение можно превратить в True или False
# Общее правило: "пусто" или "ноль" = False, всё остальное = True

# Числа:
print(bool(0))       # 0 (ноль) = False
print(bool(42))      # Любое число кроме 0 = True
print(bool(-5))      # Даже отрицательное (не ноль!) = True

# Текст (строки):
print(bool(""))      # Пустая строка "" = False
print(bool("abc"))   # Непустая строка = True
print(bool(" "))     # Даже один пробел = True (строка не пустая!)

# Специальное значение None:
print(bool(None))    # None (ничего) = False

# Целые числа (int)
a = 42
b = 1000000000000000000000  # Python поддерживает целые числа произвольной длины
c = 0b1010                  # Двоичная запись (10 в десятичной)
d = 0o777                   # Восьмеричная запись (511 в десятичной)
e = 0xFF                    # Шестнадцатеричная запись (255 в десятичной)
print(a, b, c, d, e)

# Числа с плавающей точкой (float)
pi = 3.14159
e_const = 2.71828
avogadro = 6.022e23         # Научная нотация: 6.022 × 10²³
tiny = 1e-10                # 0.0000000001
print(pi, e_const, avogadro, tiny)

# Арифметические операции
sum_result = a + pi         # Смешивание int и float дает float: 45.14159
division = 10 / 3           # Обычное деление всегда дает float: 3.3333333333333335
floor_div = 10 // 3         # Целочисленное деление (результат округляется вниз): 3
modulo = 10 % 3             # Остаток от деления: 1
power = 2 ** 8              # Возведение в степень: 256
print(sum_result, division, floor_div, modulo, power)

# Округление и другие операции
import math
print(round(pi, 2))         # Округление до 2 знаков после запятой: 3.14
print(math.floor(pi))       # Округление вниз: 3
print(math.ceil(pi))        # Округление вверх: 4
print(math.sqrt(16))        # Квадратный корень: 4.0
print(abs(-42))             # Абсолютное значение: 42

# Пример приоритета операторов
result = 2 + 3 * 4    # Умножение имеет более высокий приоритет, чем сложение
print(result)         # 14, а не 20

# Использование скобок для изменения порядка операций
result = (2 + 3) * 4  # Сначала выполняется выражение в скобках
print(result)         # 20

# Приоритет логических операторов
x = 5
y = 10
z = 15
result = x < y and y < z  # Сначала выполняются сравнения, затем логическое И
print(result)             # True

# Сложное выражение
result = x + y * z - x / y  # Порядок: умножение/деление, затем сложение/вычитание
print(result)               # 5 + (10 * 15) - (5 / 10) = 5 + 150 - 0.5 = 154.5

# Битовые операторы
a = 60            # 60 = 0011 1100 в двоичной системе
b = 13            # 13 = 0000 1101 в двоичной системе

# Битовое И (AND)
print(a & b)      # 12 = 0000 1100

# Битовое ИЛИ (OR)
print(a | b)      # 61 = 0011 1101

# Битовое исключающее ИЛИ (XOR)
print(a ^ b)      # 49 = 0011 0001

# Битовое НЕ (NOT)
print(~a)         # -61 = 1100 0011 (с учетом дополнительного кода)

# Битовый сдвиг влево
print(a << 2)     # 240 = 1111 0000 (сдвиг на 2 бита влево)

# Битовый сдвиг вправо
print(a >> 2)     # 15 = 0000 1111 (сдвиг на 2 бита вправо)