Артем Демиденко

Понятный Python. С наглядным кодом,

для детей и начинающих
 Глава 1: Знакомство с Python
В первой главе нашей книги мы погрузимся в мир Python и
научимся устанавливать его на ваш компьютер. Давайте начнем с
самого начала!
В данной книге в примерах кода стоят .... они показывают
количество пробелов, необходимое сделать перед тем или иным
участком кода. Это сделано из-за особенностей публикации книги на
платформе. В реальности вам надо заменить .... на 4 пробела.
1.1: Что такое Python?
Python – это компьютерный язык программирования. Давайте
разберемся, что это значит и почему Python так важен.
Компьютерный Язык Программирования
Для начала, давайте представим, что компьютеры – это мощные
машины, но они не могут понимать наш обычный язык, такой как
английский или русский. Они понимают только специальные
инструкции, которые называются "кодом" или "программами". Вот где
на помощь приходят компьютерные языки программирования, такие
как Python.
Простота и Понятность
Одной из особенностей Python является его простота и понятность.
В Python, код выглядит очень похоже на то, как мы общаемся друг с
другом. Вот пример:
print("Привет, мир!")
Этот код говорит компьютеру вывести на экран фразу "Привет,
мир!". Вы можете видеть, что он понятен даже без глубоких знаний
программирования.
Популярность Python
Python очень популярен среди программистов по всему миру. Это
потому, что он удобен для решения разных задач. Его используют для
создания веб-сайтов, разработки приложений, анализа данных, и даже
для искусственного интеллекта и машинного обучения.
Так что же такое Python? Это простой и понятный язык
программирования, который помогает нам говорить с компьютером и
делать интересные вещи. В этой книге мы будем изучать Python, чтобы
вы тоже могли создавать свои собственные программы и приключения
в мире компьютерного программирования!
1.2: Установка Python
Прежде чем начать программировать на Python, вам необходимо
установить этот язык программирования на свой компьютер. Ниже
приведены подробные инструкции по установке Python на различные
операционные системы:
Для Windows:
1. Перейдите на официальный сайт Python, используя ваш веб-
браузер. Адрес сайта: https://www.python.org/downloads/windows/.
2. Выберите версию Python, которую хотите установить.
Рекомендуется скачать последнюю стабильную версию (обычно она
будет отображаться в верхней части страницы).
3. Скачайте установочный файл Python для Windows. Обратите
внимание, что у вас может быть выбор между 32-битной и 64-битной
версией. Если у вас 64-разрядная версия Windows, лучше выбрать 64-
битную версию Python.
4. Запустите скачанный установочный файл Python. Убедитесь,
что установщик имеет галочку "Добавить Python X.Y в PATH" (где X.Y
– версия Python, например, 3.8). Это важно для того, чтобы вы могли
запускать Python из командной строки.
5. Нажмите кнопку "Установить сейчас" и следуйте инструкциям
на экране. Установка Python начнется и может занять несколько минут.
6. После завершения установки Python будет готов к
использованию на вашем компьютере.
Для macOS:
1. Откройте терминал (Terminal) на вашем Mac. Вы можете найти
его в папке "Утилиты" (Utilities), которая находится внутри папки
"Приложения" (Applications).
2. В терминале введите следующую команду и нажмите "Enter":
/bin/bash -c "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Эта команда устанавливает Homebrew, менеджер пакетов, который
поможет установить Python.
3. После установки Homebrew, введите следующую команду и
нажмите "Enter", чтобы установить Python:
brew install python
 Это установит Python на вашем Mac.
4. Для проверки успешной установки Python введите:
python3 –version
Вы должны увидеть версию Python.
Для Linux (Ubuntu):
1. Откройте терминал (командную строку).
2. В терминале выполните следующие команды:
sudo apt update sudo apt install python3
Эти команды обновят список пакетов и установят Python 3 на вашем
Linux-компьютере.
3. Проверьте версию Python с помощью команды:
python3 –version
Это покажет установленную версию Python.
После завершения установки Python на вашем компьютере, вы
будете готовы начать программировать на этом языке. Python успешно
установлен, и теперь вы можете переходить к созданию своих первых
программ на Python.
1.3: Знакомство с интерфейсом Python
После успешной установки Python, мы можем начать использовать
его интерактивный интерфейс. Этот интерфейс позволяет нам
взаимодействовать с Python непосредственно и выполнять команды в
режиме реального времени. Давайте более подробно рассмотрим, как
работать с ним.
1. Запуск Python интерпретатора:
• Windows: Откройте меню "Пуск" и найдите программу "Python"
или "IDLE (Python)". Запустите ее.
• macOS: Откройте "Terminal" (программа Терминал) и просто
введите python3 и нажмите "Enter". Иногда вам может потребоваться
ввести python вместо python3, в зависимости от версии Python.
• Linux: Откройте терминал и введите python3 или python в
зависимости от вашей системы.
2. Использование интерактивного режима:
Когда вы запустите интерпретатор Python, вы увидите приглашение,
похожее на >>>. Это место, где вы можете вводить команды Python.
Например, попробуйте ввести следующую команду:
print("Привет, мир!")
 После нажатия "Enter" вы увидите вывод "Привет, мир!"
непосредственно под вашей командой.
3. Простой расчет:
Python можно использовать как калькулятор. Попробуйте выполнить
арифметические операции:
2+3
Вы увидите результат 5.
4. Выход из интерпретатора:
Чтобы выйти из интерпретатора Python и вернуться в обычный
командный интерфейс, введите exit() или quit() и нажмите "Enter".
5. Сохранение программы:
Интерактивный режим полезен для быстрых проверок и
экспериментов, но настоящие программы обычно пишутся в текстовых
файлах с расширением .py. Вы создаете файл с кодом, сохраняете его,
а затем запускаете через командную строку с помощью команды
python имя_файла.py.
Этот интерфейс Python позволяет вам испытывать код по шагам и
моментально видеть результаты выполнения каждой команды. Он
будет вашим верным спутником в процессе изучения и использования
Python.
1.4: Заключение
В первой главе нашей книги мы познакомились с Python, установили
его на нашем компьютере и даже выполнили первую программу.
Поздравляю вас с первым шагом в мир программирования!
Давайте подведем итоги того, что мы узнали:
1. Python – это язык программирования: Это средство, которое
позволяет вам говорить с компьютером на его языке. Python легко
читать и писать, что делает его отличным выбором для начинающих
программистов.
2. Установка Python: Мы научились устанавливать Python на
компьютер, что позволяет нам создавать и запускать программы.
3. Интерфейс Python: Мы познакомились с интерактивным
интерфейсом Python, где мы можем вводить команды и видеть
результаты немедленно. Это помогает нам экспериментировать и
учиться.
Теперь, когда у нас есть Python на компьютере и небольшое
представление о том, как им управлять, мы готовы перейти к более
интересным аспектам программирования. В следующей главе мы
начнем изучать базовые концепции, такие как переменные и типы
данных. Эти знания помогут нам создавать более сложные программы.
Не бойтесь ошибок или неудач. Программирование – это искусство
решать задачи, и ошибки – это часть этого процесса. Важно только
продолжать учиться и экспериментировать.
 Глава 2: Первая программа
В предыдущей главе мы познакомились с Python и установили его
на наш компьютер. Теперь пришло время создать нашу первую
программу! На этом этапе мы будем использовать Python как
инструмент для написания команд, которые компьютер будет
выполнять.
Наша Первая Программа
Давайте начнем с чего-то простого. Мы создадим программу,
которая выводит на экран слова "Привет, мир!". Это традиционный
способ начать изучение программирования.
print("Привет, мир!")
Разбор:
• print – это функция Python, которая выводит текст на экран.
• "Привет, мир!" – это строка, которую мы хотим вывести. Строки
обычно заключаются в двойные кавычки.
Сохранение и Запуск
Теперь, когда у нас есть программа, давайте научимся ее сохранять и
запускать.
Сохранение Программы
1. Откройте текстовый редактор на вашем компьютере. Это
может быть Notepad, Visual Studio Code, PyCharm или другой редактор
по вашему выбору.
2. Вставьте код программы в текстовый редактор:
print("Привет, мир!")
3. Сохраните файл с расширением .py. Назовите его, например,
hello.py.
Запуск Программы
Теперь, когда наш файл сохранен, давайте научимся его запускать.
1. Откройте командную строку (на Windows она может
называться "Командная строка" или "PowerShell", на MacOS и Linux –
"Терминал").
2. Перейдите в каталог, где находится ваш файл hello.py. Это
можно сделать с помощью команды cd (change directory). Например:
cd Путь\к\каталогу
 3. Когда вы находитесь в каталоге с файлом hello.py, выполните
команду:
python hello.py
Вы увидите на экране:
Привет, мир!
Python выполнил нашу программу последовательно, начиная с
верхней строки и двигаясь вниз. Поздравляю, вы только что написали,
сохранили и запустили свою первую программу на Python!
Это было ваше первое знакомство с написанием и выполнением
программ на Python. Не волнуйтесь, если что-то пока кажется
непонятным. С практикой и дальнейшим изучением вы будете
понимать Python лучше.
 Глава 3: Переменные и Типы Данных
Что такое переменные?
В программировании переменные – это контейнеры, которые
позволяют вам хранить и работать с данными. Мы можем представить
переменные как ярлыки, на которых написано имя, и эти ярлыки
можно прикрепить к разным вещам. Например, мы можем создать
переменную с именем "возраст" и присвоить ей значение, такое как 10.
Теперь мы знаем, что возраст равен 10, и мы можем использовать это
значение в наших программах.
Создание переменных в Python
В Python, создание переменных очень просто. Вы можете выбрать
имя для переменной (помните, что имена переменных могут содержать
буквы, цифры и подчеркивания, но не могут начинаться с цифры) и
затем использовать знак равенства (=) для присвоения значения этой
переменной. Например:
возраст = 10
Теперь у нас есть переменная "возраст", которая содержит значение
10.
Типы Данных
В Python существует несколько различных типов данных, и они
определяют, какие виды значений может хранить переменная. Вот
некоторые из наиболее распространенных типов данных:
1. Целые числа (integers): Этот тип данных используется для
хранения целых чисел, например, 10, -5, 1000 и так далее.
2. Десятичные числа (floats): Этот тип данных используется для
хранения чисел с плавающей точкой, таких как 3.14, -0.5, 2.0 и другие
числа с десятичной точкой.
3. Строки (strings): Строки используются для хранения текста.
Например, "Привет, мир!" – это строка.
4. Булевы значения (booleans): Булевы значения могут быть только
двух видов: True (истина) или False (ложь). Они используются для
представления логических условий.
Примеры использования переменных и типов данных
 Давайте посмотрим на примеры использования переменных и типов
данных:
имя = "Алиса"
возраст = 12
рост = 150.5
прошел_тест = True
В этом примере мы создали четыре переменные:
• "имя" содержит строку "Алиса".
• "возраст" содержит целое число 12.
• "рост" содержит число с плавающей точкой 150.5.
• "прошел_тест" содержит булевое значение True.
Изменение Значения Переменных
Вы можете изменять значения переменных, просто присваивая им
новые значения. Например:
возраст = 13
Теперь значение переменной "возраст" равно 13, а не 12.
Вывод Значений переменных
Чтобы увидеть значения переменных, вы можете использовать
функцию print(). Например:
print(имя)
print(возраст)
Этот код выведет значения переменных "имя" и "возраст" на экран.
В этой главе мы узнали, что такое переменные, как их создавать,
какие существуют типы данных, и как изменять значения переменных.
Понимание переменных и типов данных – это фундаментальная часть
программирования, и это позволяет нам хранить и манипулировать
информацией в наших программах.
 Глава 4: Операторы и Выражения
1: Арифметические операторы
Арифметические операторы – это специальные символы в Python,
которые используются для выполнения математических операций. Вот
некоторые из них:
Сложение (+): Оператор сложения используется для сложения двух
чисел. Например:
результат = 5 + 3
print(результат) # Выведет: 8
Вычитание (-): Оператор вычитания используется для вычитания
одного числа из другого. Например:
результат = 7 – 2
print(результат) # Выведет: 5
Умножение (*): Оператор умножения используется для умножения
двух чисел. Например:
результат = 4 * 6
print(результат) # Выведет: 24
Деление (/): Оператор деления используется для деления одного
числа на другое. Важно помнить, что результат деления всегда будет
числом с плавающей точкой (десятичной дробью). Например:
результат = 8 / 2
print(результат) # Выведет: 4.0
Деление по модулю (%): Оператор деления по модулю возвращает
остаток от деления одного числа на другое. Представь, у тебя есть 10
конфет, и ты хочешь поделить их между тремя своими друзьями. Ты
делишь конфеты и видишь, что у тебя осталась 1 конфета. Это деление
по модулю! Например:
остаток = 10 % 3
print(остаток) # Выведет: 1
Операция деления по модулю – это как посчитать остаток, который
остается после того, как мы поделили одно число на другое.
2: Операторы сравнения
Операторы сравнения используются для сравнения двух значений.
Они всегда возвращают либо True (истина), либо False (ложь). Вот
некоторые операторы сравнения:
Равно (==) – это когда две вещи идентичны:
Представь, у тебя есть две машины, и они выглядят точно
одинаково: у них одинаковые цвета, одинаковые колеса и одинаковые
фары. Ты можешь сказать, что эти две машины равны, потому что они
одинаковы по своему внешнему виду.
Теперь давай посмотрим, как это работает на Python:
машина1 = "красная, 4 колеса"
машина2 = "красная, 4 колеса"

если_равны = (машина1 == машина2)

если_равны будет True, потому что машина1 и машина2 одинаковы

по своему описанию – обе красные и имеют 4 колеса.
Так что оператор "Равно (==)" используется, чтобы сравнивать две
вещи и убедиться, что они идентичны, как две одинаковые машины.
Если они идентичны, то результатом сравнения будет "True" (истина);
если нет, то "False" (ложь).
"Не равно" (!=) – это как сравнение игрушек:
Допустим, у тебя и у твоего друга есть коробки с игрушками. Ты
хочешь узнать, разные ли у вас игрушки или одинаковые. Если
игрушки в твоей коробке не такие же, как у друга, то ты говоришь "не
равно"!
Давай на Python создадим пример:
твои_игрушки = ["машинка", "кукла", "мяч"]
другие_игрушки = ["машинка", "кубики", "мяч"]

если твои_игрушки != другие_игрушки:

....print("Твои игрушки не такие же, как у друга!")
else:
....print("Твои игрушки такие же, как у друга!")
В этом примере мы используем оператор "не равно" (!=) для
сравнения твоих игрушек и игрушек друга. Если они не одинаковые
(то есть, хотя бы одна игрушка разная), мы выводим сообщение, что у
вас разные игрушки.
Итак, оператор "не равно" (!=) используется для сравнения двух
вещей и говорит нам, разные ли они или нет.
 Больше (>) – это как игра в сравнение чисел. Давай представим, что
у нас есть два числа, скажем, 7 и 3. Оператор "больше (>)" помогает
нам определить, кто из них больше, как в конкурсе.
Если мы спрашиваем Python, "7 больше, чем 3?" – Python ответит
"Да!" и покажет нам True (правда). Это как сказать, что "7 – это
больше, чем 3!"
Таким образом, оператор "больше (>)" помогает нам сравнивать
числа и определять, какое из них больше. Если число слева от
оператора больше числа справа, Python скажет "Да" и выведет True.
Если не так, то Python скажет "Нет" и выведет False (ложь).
результат = 7 > 4
print(результат) # Выведет: True
Меньше (<): Так же как и больше, только наоборот. Проверяет,
меньше ли одно значение, чем другое.
результат = 3 < 6
print(результат) # Выведет: True
Больше или равно (>=) – это способ сравнения двух чисел или
величин, чтобы узнать, одно из них больше или равно другому.
Давай представим, что у нас есть два стакана с мармеладками. В
первом стакане у нас 5 мармеладок, а во втором стакане 3 мармеладки.
Мы можем использовать оператор "больше или равно (>=)" для
сравнения количества мармеладок в этих стаканах.
Если мы скажем: "Мармеладок в первом стакане больше или равно,
чем во втором стакане?", то это значит, что мы проверяем, есть ли в
первом стакане хотя бы столько же мармеладок, сколько во втором, или
даже больше.
Если это правда (если в первом стакане 5 мармеладок, а во втором
3), то оператор "больше или равно (>=)" даст нам ответ "да" или True.
Но если бы в первом стакане было бы, например, только 2 мармеладки,
то оператор дал бы нам ответ "нет" или False.
Так что "больше или равно (>=)" говорит нам о том, есть ли у нас
достаточно или даже больше чего-то, чем в чем-то ещё.
количество_мармеладок_в_первом_стакане = 5
количество_мармеладок_во_втором_стакане = 3

если_больше_или_равно =
количество_мармеладок_в_первом_стакане >=
количество_мармеладок_во_втором_стакане

если_больше_или_равно:
....print("Мармеладок в первом стакане больше или равно, чем во
втором стакане.")
else:
....print("Мармеладок в первом стакане меньше, чем во втором
стакане.")
В этом примере сначала мы устанавливаем количество мармеладок в
первом и втором стаканах (5 и 3 соответственно). Затем мы используем
оператор "больше или равно (>=)" для сравнения этих значений и
сохраняем результат в переменной если_больше_или_равно.
Затем мы проверяем значение если_больше_или_равно с помощью
условной конструкции if. Если значение равно True, мы выводим
сообщение "Мармеладок в первом стакане больше или равно, чем во
втором стакане." В противном случае (else), если значение False, мы
выводим "Мармеладок в первом стакане меньше, чем во втором
стакане."
Этот код демонстрирует, как оператор "больше или равно (>=)"
используется для сравнения значений в Python.
Меньше или равно (<=): Проверяет, меньше или равно ли одно
значение другому.
Давайте представим ситуацию, где у вас есть яблоки и вы хотите
узнать, сколько из них можно поделить между детьми так, чтобы
каждый получил хотя бы одно яблоко. Вот как можно использовать
оператор <=:
# Количество яблок и количество детей
количество_яблок = 10
количество_детей = 3

# Проверяем, можно ли поделить яблоки равномерно между детьми

если количество_яблок <= количество_детей:
....print("Яблок хватит на всех!")
else:
....print("Яблок не хватит на всех.")
В этом примере мы сравниваем количество_яблок с
количество_детей. Если количество_яблок меньше или равно
количество_детей, то программа выводит "Яблок хватит на всех!".
Представьте, что у вас есть 10 яблок и 3 ребенка. Поскольку 10
яблок меньше или равно 3 детям, то программа сообщит, что яблок
хватит на всех.
Это простой способ использования оператора <= для сравнения
чисел и принятия решений в коде.
3: Логические операторы
Логические операторы используются для комбинирования условий
и выполняют логические операции. Вот некоторые из них:
"И" (and)
Оператор "И" (and) используется, чтобы проверить, выполняются ли
оба условия, которые мы передали. Если оба условия истинны (равны
True), то оператор and возвращает True. Если хотя бы одно из условий
ложно (False), то оператор and возвращает False.
Пример:
я_люблю_мороженое = True
я_голоден = True

если я_люблю_мороженое and я_голоден:

....print("Давайте идти за мороженым!")
else:
....print("Давайте подождем с мороженым.")
В этом примере есть два условия:
1. я_люблю_мороженое равно True, потому что я действительно
люблю мороженое.
2. я_голоден равно True, потому что я действительно голоден.
Из-за оператора and оба условия истинны, поэтому мы пойдем за
мороженым. Если бы хотя бы одно из условий было ложным, мы бы
подождали с мороженым.
Таким образом, оператор "И" (and) позволяет проверить,
выполняются ли два условия одновременно, прежде чем выполнять
какое-либо действие.
"Или" (or) возвращает True, если хотя бы одно из условий истинно.
Давайте представим, что у нас есть два домашних питомца: кот и
собака. Если хотя бы один из них голоден, то мы идем их кормить.
Вот как это может быть представлено в Python:
кот_голоден = True # Это означает, что кот голоден
 собака_голодна = False # Это означает, что собака не голодна

if кот_голоден or собака_голодна:
....print("Идем кормить питомцев!")
else:
....print("Наши питомцы не голодны, они счастливы!")
В этом коде мы используем оператор or для проверки, голоден ли
хотя бы один из питомцев. В данном случае, кот голоден, поэтому
условие истинное, и мы идем кормить питомцев.
“Не” (not)
Оператор "not" просто инвертирует (меняет) значение условия. Если
условие истинно (True), то "not" сделает его ложным (False), и
наоборот.
Вот пример:
свет_включен = True # Предположим, свет в комнате включен.

if not свет_включен:
....print("Свет выключен.")
else:
....print("Свет включен.")
Объяснение:
1. Мы создали переменную свет_включен и установили ее
значение в True, предполагая, что свет в комнате включен.
2. Затем мы используем условный оператор if, чтобы проверить,
является ли условие not свет_включен истинным или ложным. Здесь
not инвертирует значение свет_включен. Если свет был включен
(свет_включен равно True), то not свет_включен станет False.
3. Если условие not свет_включен истинно (то есть свет
выключен), программа выводит "Свет выключен.". В противном
случае она выводит "Свет включен."
Таким образом, оператор "not" меняет значение условия, что
позволяет нам делать проверки на противоположные события. Это
полезно, когда нужно проверить, например, "Если свет выключен, то
выполнить какое-то действие."
Упражнение 1: Арифметические выражения
1. Напишите программу, которая вычисляет сумму двух чисел,
введенных пользователем.
 2. Создайте программу, которая находит площадь прямоугольника
по его длине и ширине.
3. Разработайте программу, которая переводит температуру из
градусов Цельсия в градусы Фаренгейта по формуле: F = C * 9/5 + 32.
Упражнение 2: Операторы сравнения и условные операторы
1. Попросите пользователя ввести свой возраст. Затем
используйте условный оператор для проверки, является ли он
совершеннолетним (старше 18 лет) и выведите соответствующее
сообщение.
2. Напишите программу, которая проверяет, является ли
введенное число четным или нечетным, и выводит соответствующее
сообщение.
3. Создайте калькулятор индекса массы тела (ИМТ). Попросите
пользователя ввести свой вес (в килограммах) и рост (в метрах), затем
вычислите ИМТ по формуле: ИМТ = вес / (рост * рост). Выведите
сообщение о состоянии здоровья на основе рассчитанного ИМТ.
Упражнение 3: Логические операторы
1. Попросите пользователя ввести число. Проверьте, лежит ли
оно в интервале от 10 до 20 с помощью логических операторов.
Выведите соответствующее сообщение.
2. Создайте программу, которая проверяет, является ли год,
введенный пользователем, високосным. Год високосный, если он
делится на 4, но не делится на 100, за исключением случаев, когда он
делится на 400.
3. Попросите пользователя ввести баллы за тест. Проверьте,
прошел ли он тест, если баллы составляют 60 или более, и ответьте
соответствующим сообщением.
 Глава 5: Условные операторы и
Ветвление
В этой главе мы узнаем, как программы могут принимать решения и
выполнять разные действия в зависимости от условий. Мы используем
условные операторы, чтобы создавать ветвления в коде.
5.1. Что такое Условные Операторы?
В этом разделе главы, мы погрузимся в мир условных операторов и
узнаем, как они позволяют программам принимать решения.
Что такое условные операторы?
Условные операторы – это специальные инструкции в
программировании, которые позволяют программе выполнять
определенные действия в зависимости от условий. Это как принятие
решений в повседневной жизни: если что-то верно, мы делаем одно,
если нет – другое.
Зачем нужны условные операторы?
Условные операторы делают программы умнее и более
интересными. Ведь они позволяют программе реагировать на действия
пользователя или на какие-то изменения в окружающей среде.
Пример:
Представьте, что вы пишете программу для игры в "Камень,
ножницы, бумага". Когда игрок выбирает "камень", а компьютер –
"ножницы", программа должна сказать, что игрок выиграл. Но если
компьютер выбирает "бумагу", то компьютер выигрывает. Тут
условный оператор позволяет программе определить, кто выиграл и
что сделать дальше.
Использование оператора if:
Самый базовый условный оператор – это if. Он выглядит так:
if условие:
....# код, который выполняется, если условие верно
Пример:
возраст = 12
if возраст < 18:
....print("Вы слишком молоды для голосования.")
 В этом примере, если возраст меньше 18 лет, программа выведет
сообщение о том, что человек слишком молод для голосования.
Ключевые слова в условных операторах:
• if: Это ключевое слово, которое начинает условный оператор.
• условие: Это выражение, которое проверяется на истинность
(True) или ложность (False).
• : (двоеточие): Обязательное, оно обозначает начало блока кода,
который будет выполняться, если условие верно.
• Отступы: Важно, чтобы весь код внутри блока if имел
одинаковый отступ, чтобы Python понимал, что он относится к
условию.
Заключение:
Условные операторы – это мощный инструмент программирования,
который позволяет программам принимать решения и вести себя в
зависимости от ситуации. Мы только начали изучать их, и в
следующих разделах этой главы мы углубимся в их использование и
применение в различных сценариях.
5.2. Оператор if
Оператор if – это один из наиболее основных и важных элементов в
программировании. Он позволяет программе выполнять определенные
действия только в случае, если какое-то условие истинно (True). Если
условие ложно (False), то код внутри блока if не выполняется.
Пример использования оператора if:
age = 12

if age < 18:

....print("Вы слишком молоды, чтобы голосовать.")
В этом примере, мы создали переменную age и установили ее
значение в 12. Затем мы используем оператор if, чтобы проверить, если
значение age меньше 18. Если это условие истинно (что в данном
случае правда), то программа выполнит инструкцию print, и на экране
будет выведено сообщение "Вы слишком молоды, чтобы голосовать."
Синтаксис оператора if:
if условие:
....# выполняемый код, если условие истинно
• Ключевое слово if указывает начало условия.
 • За ним следует условие, которое проверяется, и оно заключено в
круглые скобки.
• Затем идет двоеточие :, которое обозначает начало блока кода,
который будет выполняться, если условие истинно.
• Все строки внутри блока кода if должны иметь одинаковый
отступ (обычно 4 пробела или одна табуляция).
Пример использования if с else:
Иногда бывает полезно иметь вариант действий, который
выполняется, если условие ложно. Для этого используется оператор
else:
age = 20

if age < 18:

....print("Вы слишком молоды, чтобы голосовать.")
else:
....print("Добро пожаловать на выборы!")
В этом примере, если age меньше 18, программа выводит "Вы
слишком молоды, чтобы голосовать." В противном случае, если age
больше или равно 18, программа выводит "Добро пожаловать на
выборы!"
Оператор if является основой для создания логики в программах. Он
позволяет программе принимать решения и выполнять разные
действия в зависимости от текущих условий, что делает программы
более умными и полезными.
5.3. Операторы elif и else
После того, как мы научились использовать оператор if для
выполнения кода в зависимости от истинности (True) условия, давайте
поговорим о том, как добавить больше гибкости к нашим программам
с помощью операторов elif и else.
Оператор elif (else if)
Иногда у нас может быть несколько условий, и мы хотим проверить
их поочередно и выполнить соответствующий код, как только одно из
условий станет истинным. Вот как это работает:
условие1 = False
условие2 = True

if условие1:
 ....# Этот код выполняется, если условие1 истинно
....print("Условие 1 выполнено")
elif условие2:
....# Этот код выполняется, если условие2 истинно
....print("Условие 2 выполнено")
В этом примере, условие1 ложно (False), поэтому код внутри if не
выполняется. Затем мы проверяем условие2, и оно истинно (True),
поэтому выполняется код внутри elif.
Оператор else
Оператор else выполняет код, если все предшествующие условия (в
if и elif) оказались ложными. Вот пример:
условие1 = False
условие2 = False

if условие1:
....print("Условие 1 выполнено")
elif условие2:
....print("Условие 2 выполнено")
else:
....# Этот код выполняется, если ни одно из условий не истинно
....print("Ни одно из условий не выполнено")
В этом примере оба условие1 и условие2 ложны, поэтому
выполняется код внутри else.
Чем это полезно?
Операторы elif и else позволяют нам создавать более сложные
логические структуры в программах. Мы можем проверять множество
условий и выполнять соответствующий код. Например, в игре, если
игрок набрал определенное количество очков, мы можем поздравить
его с победой (if), если он набрал немного меньше, мы можем
предложить попробовать еще (elif), и если он набрал очень мало, мы
можем сказать ему, что нужно больше тренироваться (else).
Задача: Меню в Магазине Игрушек
Представьте, что вы управляете магазином игрушек, и у вас есть
разные игрушки для продажи. Вы хотите создать программу, которая
поможет вашим маленьким клиентам выбрать игрушку в зависимости
от их предпочтений.
Ваша программа должна сделать следующее:
 1. Поприветствовать клиента и спросить, какая игрушка ему
нравится: мяч, кукла или конструктор.
2. Если клиент выбирает "мяч", программа должна сказать:
"Отличный выбор! Вот ваш мяч."
3. Если клиент выбирает "кукла", программа должна сказать:
"Замечательно! Вот ваша кукла."
4. Если клиент выбирает "конструктор", программа должна
сказать: "Супер! Вот ваш конструктор."
5. Если клиент вводит что-то другое, программа должна сказать:
"Извините, у нас нет такой игрушки."
Используйте операторы if, elif и else, чтобы обработать разные
выборы клиента. Не забудьте попросить клиента ввести свой выбор
(например, "мяч", "кукла" или "конструктор") и сохранить этот выбор
в переменной, чтобы проверить его с помощью условий.
Решение:
# Приветствие
print("Привет! Добро пожаловать в Магазин Игрушек!")

# Запрос выбора игрушки

игрушка = input("Какая игрушка вас интересует? (мяч, кукла,
конструктор): ")

# Проверка выбора и выдача соответствующей игрушки

if игрушка == "мяч":
....print("Отличный выбор! Вот ваш мяч.")
elif игрушка == "кукла":
....print("Замечательно! Вот ваша кукла.")
elif игрушка == "конструктор":
....print("Супер! Вот ваш конструктор.")
else:
....print("Извините, у нас нет такой игрушки.")
Когда вы запустите этот код, программа поприветствует
пользователя, попросит его выбрать игрушку, а затем, в зависимости от
выбора, выдаст соответствующее сообщение. Если пользователь
введет что-то, что не соответствует "мяч", "кукла" или "конструктор",
программа выдаст сообщение об отсутствии выбранной игрушки.
5.4. Примеры Игр и Задач
 Пример 1: Угадай число
import random

# Загадываем случайное число от 1 до 10

загаданное_число = random.randint(1, 10)

# Попросим игрока угадать число

попытка = int(input("Попробуй угадать число от 1 до 10: "))

# Проверяем, угадал ли игрок

if попытка == загаданное_число:
....print("Поздравляю, ты угадал число!")
else:
....print("Увы, не угадал. Это было число", загаданное_число)
Объяснение:
• Мы импортируем модуль random, чтобы создать случайное
число.
• Загадываем число и сохраняем его в переменной
загаданное_число.
• Просим игрока ввести свою догадку с помощью input и
сохраняем ее в переменной попытка.
• Затем сравниваем попытка с загаданное_число. Если они
равны, выводим сообщение о победе. Иначе выводим сообщение с
правильным числом.
Пример 2: Определение времени суток
# Спросим пользователя который час
часы = int(input("Который сейчас час? "))

# Определяем время суток

if 5 <= часы < 12:
....print("Доброе утро!")
elif 12 <= часы < 18:
....print("Добрый день!")
else:
....print("Добрый вечер!")
Объяснение:
 Мы используем функцию input(), чтобы получить ввод
пользователя. input() просит пользователя ввести данные с клавиатуры
и возвращает введенное значение в виде строки (текста). Чтобы
работать с временем, нам нужно преобразовать введенное значение в
целое число, поэтому мы используем int() для этой цели. Результат
сохраняется в переменной часы.
• В первой строке if 5 <= часы < 12: мы проверяем, находится ли
значение часы в интервале от 5 (включительно) до 12 (не
включительно). Если это условие истинно (что означает, что введенное
число находится между 5 и 12 часами), то мы выводим сообщение
"Доброе утро!".
• Если первое условие ложно, мы переходим к следующему с
помощью elif 12 <= часы < 18:. Здесь мы проверяем, находится ли
значение часы в интервале от 12 (включительно) до 18 (не
включительно). Если это условие истинно (что означает, что введенное
число находится между 12 и 18 часами), то мы выводим сообщение
"Добрый день!".
• Если ни одно из условий выше не выполняется (то есть,
введенное число меньше 5 или больше или равно 18), мы попадаем в
блок else и выводим сообщение "Добрый вечер!".
Этот код позволяет определить, какое время суток введено
пользователем и вывести соответствующее приветствие.
5.5. Вложенные Условия
Вложенные условия – это концепция, при которой одно условие
находится внутри другого. Они используются, когда вам нужно
рассматривать более сложные сценарии, зависящие от нескольких
условий. Вложенные условия могут помочь программе принимать
более точные решения в зависимости от различных факторов.
Пример: Игра "Многогранник"
Давайте создадим программу для игры, где пользователь выбирает
многогранник (геометрическую фигуру) по количеству его сторон. Мы
будем использовать вложенные условия, чтобы определить выбор
пользователя.
print("Добро пожаловать в игру 'Многогранник'!")
print("Выберите количество сторон многогранника:")
 sides = int(input())

if sides == 3:
....print("Вы выбрали треугольник.")
elif sides == 4:
....print("Вы выбрали четырехугольник.")
....print("Дополнительно, это может быть квадрат, прямоугольник
или ромб.")
....
....shape = input("Уточните тип: ")

....if shape == "квадрат":

........print("Вы выбрали квадрат.")
....elif shape == "прямоугольник":
........print("Вы выбрали прямоугольник.")
....elif shape == "ромб":
........print("Вы выбрали ромб.")
....else:
........print("Не удалось определить тип четырехугольника.")
elif sides == 5:
....print("Вы выбрали пятиугольник.")
else:
....print("Извините, мы не знаем такой многогранник.")
Объяснение:
print("Добро пожаловать в игру 'Многогранник'!")
Эта строка выводит приветствие для пользователя. print() – это
функция Python, которая выводит текст на экран.
print("Выберите количество сторон многогранника:")
Здесь мы выводим приглашение пользователя к выбору количества
сторон многогранника.
sides = int(input())
Эта строка считывает введенное пользователем значение и
сохраняет его в переменной sides. Функция input() позволяет вводить
текст с клавиатуры. Мы используем int() для преобразования
введенного текста в целое число, так как количество сторон – это
числовое значение.
if sides == 3:
 Здесь мы начинаем условный оператор if. Он проверяет, равно ли
значение переменной sides числу 3.
....print("Вы выбрали треугольник.")
Если условие в операторе if истинно (то есть sides равно 3), то
программа выводит текст "Вы выбрали треугольник."
elif sides == 4:
Здесь мы используем оператор elif, который проверяет следующее
условие: равно ли значение sides числу 4.
....print("Вы выбрали четырехугольник.")
Если условие в операторе elif истинно (то есть sides равно 4), то
программа выводит текст "Вы выбрали четырехугольник."
....print("Дополнительно, это может быть квадрат, прямоугольник
или ромб.")
Эта строка выводит дополнительную информацию о том, что
четырехугольник может быть квадратом, прямоугольником или
ромбом.
....shape = input("Уточните тип: ")
Здесь мы используем input() для того, чтобы позволить
пользователю уточнить тип четырехугольника. Введенное
пользователем значение будет сохранено в переменной shape.
if shape == "квадрат":
Эта строка начинает вложенный оператор if, который проверяет,
равно ли значение переменной shape строке "квадрат".
........print("Вы выбрали квадрат.")
Если условие во вложенном if истинно (то есть shape равно
"квадрат"), то программа выводит текст "Вы выбрали квадрат."
Остальные строки во вложенных условиях (elif shape ==
"прямоугольник":, elif shape == "ромб":) работают аналогично,
проверяя тип четырехугольника, который выбрал пользователь, и
выводя соответствующие сообщения.
....else:
Эта строка начинает блок else во вложенных условиях. Если ни одно
из условий внутри вложенных if и elif не истинно, то программа
выполняет код, находящийся в блоке else.
........print("Не удалось определить тип четырехугольника.")
Если ни одно из условий во вложенных if и elif не было истинным,
программа выводит текст "Не удалось определить тип
четырехугольника."
elif sides == 5:
Эта строка начинает еще один блок elif, который проверяет, равно ли
значение sides числу 5.
....print("Вы выбрали пятиугольник.")
Если условие в этом блоке elif истинно (то есть sides равно 5), то
программа выводит текст "Вы выбрали пятиугольник."
else:
Эта строка завершает условный оператор if-elif-else, который
начался в начале программы. Если ни одно из условий в этом
операторе не было истинным, программа выполняет код в блоке else.
....print("Извините, мы не знаем такой многогранник.")
Если ни одно из условий в предыдущих блоках не было истинным,
программа выводит сообщение "Извините, мы не знаем такой
многогранник."
Этот пример демонстрирует, как вложенные условия позволяют
программе принимать решения на основе разных факторов и
обеспечивать более точную логику выполнения кода в зависимости от
выбора пользователя.
5.6. Ошибки и Отладка
При работе с условными операторами, такими как if, elif, и else,
могут возникнуть ошибки. Ошибки в программе могут привести к
неправильным результатам или к тому, что программа вообще не будет
работать. В этой части главы мы поговорим о распространенных
ошибках и способах их отладки.
5.6.1. Ошибки в Условных Операторах
При работе с условными операторами в Python могут возникнуть
разные виды ошибок. Давайте рассмотрим их более подробно:
Синтаксические ошибки: Эти ошибки возникают из-за нарушения
синтаксиса Python, то есть правил написания кода на этом языке.
Например:
if x > 5 # Забыто двоеточие в конце строки
Для исправления синтаксических ошибок, вам нужно просто
следовать правилам языка Python, включая правильное использование
двоеточия после оператора if.
Логические ошибки: Эти ошибки не связаны с синтаксисом, но с
логикой вашей программы. Они могут привести к неправильным
результатам. Например:
if x > 5:
....print("x больше 5")
else:
....print("x меньше 5") # Здесь ошибка, должно быть "x меньше или
равно 5"
В данном случае, ошибка заключается в неправильной логической
операции. Вместо "x меньше 5" должно быть "x меньше или равно 5",
чтобы точно отражать условие.
Индентация (отступы): Python очень чувствителен к отступам.
Неправильные отступы могут вызвать ошибки. Например:
if x > 5:
print("x больше 5") # Неправильный отступ
В этом случае, код после оператора if имеет неправильный отступ.
Он должен быть с отступом, чтобы указать, что он является частью
блока кода, который будет выполняться, если условие истинно.
Неопределенные переменные: Если вы используете переменные в
условиях, которые не были определены ранее в коде, это вызовет
ошибку. Например:
if y > 10:
....print("y больше 10")
Если переменная y не была определена до этого момента в
программе, вы получите ошибку "NameError".
Для нахождения и устранения ошибок в условных операторах,
обратите внимание на сообщения об ошибках, которые Python
предоставляет. Они часто указывают на местоположение ошибки и
могут помочь вам быстро ее исправить. Отладочные методы, такие как
добавление print для отслеживания значений переменных, также
могут быть очень полезными при поиске ошибок.
5.6.2. Отладка (Debugging)
Отладка – это важный процесс в программировании, который
позволяет находить и устранять ошибки в вашем коде. При работе с
условными операторами, такими как if, elif, и else, могут возникать
различные типы ошибок. Вот некоторые полезные методы отладки
кода с условными операторами:
1. Используйте вывод на экран (print):
 Один из наиболее простых и распространенных способов отладки –
добавление операторов print, чтобы выводить значения переменных и
проверять, какие условия выполняются. Вы можете добавлять print в
код, чтобы видеть, какие значения имеют переменные в разных точках
программы:
x=7
print("Значение x:", x)
if x > 5:
....print("x больше 5")
else:
....print("x меньше или равно 5")
Этот метод позволяет вам наблюдать за ходом выполнения
программы и определять, где возникают проблемы.
2. Используйте комментарии:
Добавление комментариев к коду поможет вам и другим
разработчикам понимать, что вы пытались сделать в каждой части
программы. Комментарии – это текстовые объяснения, которые
игнорируются интерпретатором Python, но могут быть полезными для
человека:
# Проверяем, больше ли x 5
if x > 5:
....print("x больше 5")
else:
....print("x меньше или равно 5")
Комментарии помогают сделать ваш код более читаемым и
понятным.
3. Используйте отладчик (Debugger):
Python предоставляет отладчик под названием pdb (Python
Debugger), который позволяет вам пошагово выполнять код и изучать
значения переменных на каждом этапе. Вы можете вставить
следующий код в свою программу, чтобы начать отладку:
import pdb
pdb.set_trace()
Когда интерпретатор Python достигнет этой строки, выполнение
программы приостановится, и вы сможете использовать различные
команды для изучения переменных и выполнения кода по шагам.
4. Используйте интерактивные среды разработки (IDE):
 Многие среды разработки Python, такие как PyCharm, Visual Studio
Code и Jupyter Notebook, предоставляют удобные инструменты для
отладки. Они позволяют вам устанавливать точки останова
(breakpoints), а также просматривать значения переменных в режиме
реального времени во время выполнения программы.
При наличии этих инструментов вы можете упростить процесс
отладки и быстрее находить и исправлять ошибки в вашем коде.
5.6.3. Задача для Практики
Давайте подробно разберем задачу, в которой мы будем отлаживать
программу, определяющую, является ли число четным или нечетным.
Исходный код программы выглядит следующим образом:
number = 7

if number % 2 == 0:
....print("Число четное")
else:
....print("Число нечетное")
Программа должна вернуть "Число нечетное" для числа 7, так как 7
– нечетное число. Однако, по какой-то причине, программа возвращает
"Число четное". Давайте исправим это.
Шаг 1: Изучение Кода
Первый шаг – это внимательное изучение кода. Мы видим, что
программа использует оператор %, чтобы проверить остаток от
деления числа на 2. Если остаток равен 0, программа выводит "Число
четное", в противном случае – "Число нечетное".
Шаг 2: Проверка Числа
Чтобы понять, почему программа возвращает неверный результат,
мы можем добавить вывод на экран, чтобы увидеть значение number и
результат операции number % 2:
number = 7

print("Число:", number)
print("number % 2 =", number % 2)

if number % 2 == 0:
....print("Число четное")
else:
 ....print("Число нечетное")
Шаг 3: Запуск и Отладка
После добавления этих строк и запуска программы, мы увидим
следующий вывод:
Число: 7
number % 2 = 1
Число четное
Теперь мы видим, что остаток от деления 7 на 2 действительно
равен 1, и это объясняет, почему программа выводит "Число четное",
что является неверным результатом.
Шаг 4: Исправление Кода
Чтобы исправить программу, мы должны изменить условие в
операторе if. Мы хотим проверить, равен ли остаток от деления 2
числа на 0 (что означает, что число четное), поэтому нам нужно
изменить условие следующим образом:
if number % 2 == 1:
....print("Число нечетное")
else:
....print("Число четное")
Шаг 5: Повторный Запуск
Теперь, после исправления кода, мы запускаем программу снова и
видим правильный результат:
Число: 7
number % 2 = 1
Число нечетное
Теперь программа корректно определяет, что число 7 является
нечетным.
Этот процесс называется отладкой, и он позволяет нам находить и
исправлять ошибки в наших программах, чтобы они работали
правильно.
 Глава 6: Циклы и Повторение
В предыдущих главах мы узнали, как создавать условия и делать
выбор в наших программах с помощью операторов if, elif и else. Но
что, если нам нужно многократно выполнять одно и то же действие?
Например, представьте, что вам нужно вывести числа от 1 до 10. Вы
можете написать 10 разных команды print, но это было бы
неэффективно. Вместо этого вы можете использовать циклы.
Цикл while
Первым циклом, о котором мы поговорим, будет while. Цикл while
позволяет выполнять блок кода до тех пор, пока условие истинно.
Давайте посмотрим на пример:
number = 1
while number <= 10:
....print(number)
....number = number + 1
Давайте разберем, что здесь происходит:
1. Мы создали переменную number и установили ее равной 1.
2. Затем мы начали цикл while. Условие number <= 10 говорит
Python выполнять код, пока number меньше или равно 10.
3. Внутри цикла мы выводим значение number на экран с
помощью print.
4. После этого мы увеличиваем значение number на 1 с помощью
number = number + 1.
Этот код будет выводить числа от 1 до 10. Как только number станет
равным 11, условие number <= 10 больше не будет истинным, и цикл
завершится.
Цикл for
Есть и другой способ повторить действия в Python с помощью цикла
for. Цикл for позволяет перебирать элементы в последовательности,
такой как список или строка. Вот пример:
fruits = ["яблоко", "банан", "груша"]
for fruit in fruits:
....print(fruit)
 Здесь мы создали список fruits, и цикл for перебирает каждый
элемент этого списка и выводит его на экран. Результат будет таким:
яблоко
банан
груша
Практические Задания
1. Напишите программу, которая выводит на экран числа от 1 до
20 с использованием цикла while.
2. Создайте список своих любимых цветов и используйте цикл
for, чтобы вывести их на экран.
3. Попробуйте написать программу, которая просит пользователя
ввести число, а затем выводит таблицу умножения для этого числа с
использованием цикла for.
В этой главе мы узнали о циклах while и for, которые позволяют нам
выполнять действия многократно. Это мощный инструмент в
программировании, который пригодится вам во многих задачах.
Решение 1:
number = 1 # Начинаем с числа 1
while number <= 20: # Условие: пока number меньше или равно 20
....print(number) # Выводим текущее значение number
....number = number + 1 # Увеличиваем number на 1
Этот код начинает с числа 1 и затем с использованием цикла while
выводит числа от 1 до 20. Как только number достигнет 21, условие
number <= 20 станет ложным, и цикл завершится.
Решение 2:
# Создаем список любимых цветов
favorite_colors = ["синий", "красный", "зеленый", "фиолетовый",
"оранжевый"]

# Используем цикл for для вывода цветов на экран

print("Мои любимые цвета:")
for color in favorite_colors:
....print(color)
Эта программа создает список favorite_colors, содержащий
несколько цветов, и затем использует цикл for, чтобы перебирать
элементы этого списка и выводить их на экран. В результате
выполнения программы на экране появится список моих любимых
цветов.
Решение 3:
# Запрос у пользователя ввода числа
number = int(input("Введите число для таблицы умножения: "))

# Вывод таблицы умножения для введенного числа

print(f"Таблица умножения для {number}:")
for i in range(1, 11):
....result = number * i
....print(f"{number} x {i} = {result}")
В этой программе:
1. Мы запрашиваем у пользователя ввод числа с помощью
функции input(). Введенное пользователем значение преобразуется в
целое число с помощью int() и сохраняется в переменной number.
2. Затем мы используем цикл for, который перебирает значения
от 1 до 10 (включительно) с помощью range(1, 11).
3. Внутри цикла мы вычисляем результат умножения введенного
числа number на текущее значение i и выводим его на экран.
Таким образом, программа создает таблицу умножения для числа,
введенного пользователем, и выводит ее на экран.
 Глава 7: Функции
Привет, юный программист! Сегодня мы поговорим о чем-то очень
важном в мире программирования – функциях. Функции – это как
маленькие магические ящики, которые берут что-то, делают с этим
что-то и возвращают результат.
Что такое функции?
Давай сначала попробуем представить, что ты кулинар. Когда ты
готовишь пиццу, ты используешь разные ингредиенты, как тесто, соус,
сыр и томаты. Функции в программировании – это как рецепты. Ты
можешь написать рецепт для приготовления пиццы, и в любой момент,
когда захочешь, приготовить пиццу, следуя этому рецепту.
Итак, функции – это такие наборы инструкций, которые выполняют
определенную задачу. Когда ты вызываешь функцию, ты говоришь
программе выполнить этот набор инструкций.
Зачем нужны функции?
Функции очень полезны, потому что они позволяют избегать
повторения кода. Представь, что у тебя есть куча разных мест в
рецептах, где используется соус для пиццы. Если ты каждый раз
пишешь один и тот же рецепт для соуса, это было бы утомительно, не
так ли? Вместо этого, ты можешь написать функцию "приготовить
соус", и просто вызывать эту функцию в любом рецепте, где нужен
соус. Это сэкономит много времени и уменьшит шанс ошибки.
Создание функций
Для создания функции в Python используется ключевое слово def.
Вот пример:
def приветствие():
....print("Привет, мир!")
Это простая функция, которая просто выводит на экран "Привет,
мир!".
Вызов функций
Чтобы наша функция что-то сделала, нам нужно ее вызвать.
Вызывать функцию – это как приготовление блюда по рецепту. Вот как
вызвать нашу функцию приветствие:
приветствие()
 Когда ты вызываешь функцию, программа выполняет инструкции,
которые находятся внутри функции. Так что после того как ты
вызовешь приветствие(), на экране появится "Привет, мир!".
Параметры и возвращаемые значения
Но функции могут делать не только одну вещь. Они могут
принимать информацию, выполнять операции с этой информацией и
возвращать результат. Например:
def удвоить(число):
....удвоенное_число = число * 2
....return удвоенное_число
Эта функция удвоить принимает один параметр, число, умножает
его на 2 и возвращает результат. Вот как использовать эту функцию:
результат = удвоить(5)
print(результат)
Этот код вызовет функцию удвоить с аргументом 5, и программа
напечатает 10, потому что удвоенное значение 5 – это 10.
Таким образом, функции – это очень важная часть
программирования. Они помогают упростить код, делать его более
понятным и избегать повторений. Ты можешь создавать свои
собственные функции для решения задач, и это делает тебя настоящим
мастером программирования!
 Глава 8: Списки и Кортежи
Когда мы говорили о переменных, мы узнали, как Python может
хранить одно значение. Но что, если у нас есть много значений,
которые нам нужно хранить и управлять? В этой главе мы узнаем о
списках и кортежах, которые позволяют нам делать именно это.
Списки
Список в Python – это набор значений, которые могут быть разных
типов данных. Вот как выглядит создание списка:
мой_список = [1, 2, 3, 4, 5]
Мы создали список мой_список, который содержит пять чисел. Мы
можем получить доступ к элементам списка по их индексам, начиная с
нуля. Например, чтобы получить первый элемент списка, мы пишем:
первый_элемент = мой_список[0]
Теперь первый_элемент будет равен 1.
Списки позволяют нам выполнять множество операций, таких как
добавление элементов, удаление элементов и многое другое. Вот
несколько примеров:
мой_список.append(6) # Добавляем 6 в конец списка.
мой_список.remove(3) # Удаляем значение 3 из списка.
длина_списка = len(мой_список) # Получаем длину списка
(количество элементов).
1. мой_список.append(6) # Добавляем 6 в конец списка.
• В этой строке мы используем метод append(), который доступен
для списков, чтобы добавить число 6 в конец списка мой_список.
После выполнения этой строки, список будет выглядеть, например,
так: [1, 2, 3, 4, 5, 6].
2. мой_список.remove(3) # Удаляем значение 3 из списка.
• В данной строке мы используем метод remove(), чтобы удалить
первое вхождение числа 3 из списка мой_список. Если бы в списке
было несколько троек, этот метод удалит только первую тройку,
которую он найдет.
3. длина_списка = len(мой_список) # Получаем длину списка
(количество элементов).
 • В этой строке мы используем функцию len(), чтобы определить
длину списка мой_список, то есть количество элементов в этом
списке. Результат (количество элементов) сохраняется в переменной
длина_списка. Например, если после выполнения первой строки у нас
был список [1, 2, 4, 5, 6], то длина_списка будет равна 5, так как в
списке 5 элементов.
Более подробно о методах мы поговорим в следующей главе.
Кортежи
Кортежи похожи на списки, но у них есть одно важное отличие: они
неизменяемые. Это означает, что после того, как вы создали кортеж, вы
не можете изменить его элементы. Вот как создать кортеж:
мой_кортеж = (10, 20, 30)
Чтобы получить доступ к элементам кортежа, вы делаете это так же,
как и к элементам списка:
первый_элемент = мой_кортеж[0]
Но если вы попытаетесь изменить элемент кортежа, Python выдаст
ошибку.
Зачем использовать списки и кортежи?
Списки и кортежи очень полезны, когда у вас есть много данных,
которые вы хотите хранить и обрабатывать. Вы можете использовать
списки, чтобы хранить списки дел, результаты игры, баллы в
соревновании и многое другое. Кортежи полезны, когда вы хотите,
чтобы данные были неизменными, например, координаты точки на
экране.
Практическое задание (можно выполнить после прочтения
следующей главы)
1. Создайте список, содержащий ваши любимые фрукты.
2. Добавьте в этот список ещё несколько фруктов.
3. Удалите один из фруктов.
4. Выведите на экран длину вашего списка фруктов.
Теперь, когда вы знаете о списках и кортежах, вы можете более
эффективно управлять данными в ваших программах!
Решение:
# Создаем список с любимыми фруктами
любимые_фрукты = ["яблоко", "банан", "апельсин"]

# Добавляем ещё несколько фруктов

 любимые_фрукты.append("груша")
любимые_фрукты.append("киви")

# Удаляем один из фруктов

любимые_фрукты.remove("банан")

# Выводим на экран длину списка фруктов

длина_списка = len(любимые_фрукты)
print("Длина списка фруктов:", длина_списка)
1. любимые_фрукты = ["яблоко", "банан", "апельсин"]
Здесь мы создаем переменную любимые_фрукты и присваиваем ей
список фруктов. Этот список содержит три элемента: "яблоко", "банан"
и "апельсин".
2. любимые_фрукты.append("груша")
Эта строка использует метод append() для добавления нового
фрукта, "груша", в конец списка любимые_фрукты.
3. любимые_фрукты.append("киви")
Аналогично предыдущей строке, мы добавляем "киви" в список
любимые_фрукты.
4. любимые_фрукты.remove("банан")
С помощью метода remove() мы удаляем элемент "банан" из списка
любимые_фрукты. Теперь этот фрукт больше не будет в списке.
5. длина_списка = len(любимые_фрукты)
Здесь мы используем функцию len(), чтобы определить длину
списка любимые_фрукты, то есть количество элементов в нем.
Результат сохраняется в переменной длина_списка.
6. print("Длина списка фруктов:", длина_списка)
Эта строка кода выводит на экран сообщение "Длина списка
фруктов:" и значение переменной длина_списка, которое
представляет собой количество фруктов в списке.
 Глава 9: Строки и Методы
В предыдущих главах мы уже узнали, что строки представляют
собой последовательность символов. Строки играют важную роль в
программировании, так как они позволяют нам работать с текстом и
обрабатывать информацию. В этой главе мы поговорим о различных
операциях с строками и методах, которые позволят нам делать с ними
множество полезных вещей.
Операции со строками
Конкатенация строк
Одной из основных операций со строками является конкатенация, то
есть объединение строк. Вы можете объединить две строки с помощью
оператора +. Давайте посмотрим на пример:
первая_строка = "Привет, "
вторая_строка = "мир!"
полная_строка = первая_строка + вторая_строка
print(полная_строка)
В результате выполнения этого кода на экране появится:
Привет, мир!
Срезы строк
Срезы позволяют вам получать подстроку из строки. Вы указываете
начальный и конечный индексы, и Python вернет вам подстроку между
этими индексами. Важно помнить, что индексы в Python начинаются с
0.
строка = "Это очень важная строка"
подстрока = строка[4:9]
print(подстрока)
В результате выполнения этого кода на экране появится:
очень
Длина строки
Чтобы узнать длину строки, вы можете использовать функцию len():
строка = "Программирование весело!"
длина = len(строка)
print("Длина строки:", длина)
В результате выполнения этого кода на экране появится:
 Длина строки: 24
Встроенные методы строк
Python предоставляет множество встроенных методов для работы со
строками. Вот некоторые из них:
upper() и lower()
Метод upper() преобразует все символы строки в верхний регистр, а
метод lower() в нижний:
строка = "Привет, Мир!"
в_верхнем_регистре = строка.upper()
в_нижнем_регистре = строка.lower()
print(в_верхнем_регистре)
print(в_нижнем_регистре)
В результате выполнения этого кода на экране появится:
ПРИВЕТ, МИР!
привет, мир!
strip()
Метод strip() удаляет пробелы и другие символы в начале и конце
строки:
строка = "....Привет, Мир!...."
очищенная_строка = строка.strip()
print(очищенная_строка)
В результате выполнения этого кода на экране появится:
Привет, Мир!
replace()
Метод replace() позволяет заменить одну подстроку на другую:
строка = "Я учусь программировать на Python"
новая_строка = строка.replace("Python", "JavaScript")
print(новая_строка)
Результат будет:
Я учусь программировать на JavaScript
append()
Хотя метод append() не применяется напрямую к строкам, он
используется для добавления элемента в конец списка. Список – это
структура данных, которая может содержать элементы разных типов,
включая строки. Давайте посмотрим на пример:
список_фруктов = ["яблоко", "банан", "груша"]
список_фруктов.append("апельсин")
 print(список_фруктов)
find()
Метод find() позволяет найти первое вхождение подстроки в строке
и вернуть индекс этого вхождения:
строка = "Это очень важная строка"
индекс = строка.find("важная")
print("Индекс:", индекс)
Результат:
Индекс: 9
Задачи для практики
1. Создайте строку, содержащую ваше имя и фамилию, и
выведите ее в верхнем регистре.
2. Создайте строку, содержащую несколько слов, разделенных
пробелами. Используя метод split(), разделите строку на список слов и
выведите его.
3. Создайте строку, содержащую несколько чисел, разделенных
запятыми. Используя методы строк, выведите сумму этих чисел.
4. Найдите и замените все вхождения определенного слова в
строке другим словом.
5. Создайте программу, которая принимает от пользователя
строку и выводит количество гласных букв в ней.
Строки и методы работы с ними – это важная часть
программирования. Практикуйтесь, и вы сможете использовать строки
для решения разных задач!
Решение 1:
имя_фамилия = "Ваше Имя Ваша Фамилия"
верхний_регистр = имя_фамилия.upper()
print(верхний_регистр)
Решение 2:
строка = "Это пример разделения слов"
список_слов = строка.split()
print(список_слов)
Решение 3:
строка_чисел = "10, 20, 30, 40, 50"
числа = строка_чисел.split(", ")
сумма = 0
 for число in числа:
....сумма += int(число)

print("Сумма чисел:", сумма)

1. строка_чисел = "10, 20, 30, 40, 50" – В этой строке мы создаем
переменную строка_чисел и присваиваем ей строку, содержащую
числа, разделенные запятыми.
2. числа = строка_чисел.split(", ") – Здесь мы используем метод
split() для разделения строки строка_чисел на список строк. Метод
split(", ") разбивает строку на элементы списка, используя запятые и
пробелы в качестве разделителей. Таким образом, после выполнения
этой строки, числа будет содержать список строк, представляющих
числа.
3. сумма = 0 – Здесь мы создаем переменную сумма и
устанавливаем ее значение равным 0. Эта переменная будет
использоваться для накопления суммы чисел.
4. for число in числа: – Это начало цикла for. Мы перебираем
каждый элемент списка числа поочередно и выполняем операции
внутри цикла для каждого числа.
5. сумма += int(число) – В этой строке мы преобразуем текущий
элемент списка числа в целое число с помощью функции int(), а затем
добавляем его к текущей сумме, хранящейся в переменной сумма.
Таким образом, мы накапливаем сумму чисел.
6. print("Сумма чисел:", сумма) – Наконец, после завершения
цикла, мы выводим результат – сумму чисел, используя функцию
print(). Результат будет отображен в виде текста "Сумма чисел:"
и фактической суммы чисел, вычисленной в предыдущем цикле.
Итак, этот код берет строку чисел, разбивает ее на отдельные числа,
суммирует их и выводит итоговую сумму.
Решение 4:
строка = "Это пример простой строки. Это строка."
замененная_строка = строка.replace("строка", "предложение")
print(замененная_строка)
Решение 5:
строка = input("Введите строку: ").lower() # Преобразуем в нижний
регистр для учета всех гласных
 гласные = "aeiou" # Список гласных букв

количество_гласных = 0

for символ in строка:

....if символ in гласные:
........количество_гласных += 1

print("Количество гласных букв в строке:", количество_гласных)

1. строка = input("Введите строку: ").lower(): Эта строка
запрашивает у пользователя ввод строки с помощью функции input().
После ввода пользователем строки, она сохраняет эту строку в
переменной строка и сразу же преобразует ее в нижний регистр с
помощью метода .lower(). Преобразование в нижний регистр делается
для того, чтобы учитывать все буквы как маленькие и избежать
проблем с учетом регистра при поиске гласных.
2. гласные = "aeiou": В этой строке создается переменная гласные,
которая содержит строку с гласными буквами английского алфавита.
3. количество_гласных = 0: Эта строка инициализирует
переменную количество_гласных, которая будет использоваться для
подсчета количества гласных букв в строке. В начале выполнения
программы ее значение равно 0.
4. for символ in строка:: Это начало цикла for. Он будет
итерироваться по каждому символу в строке строка.
5. if символ in гласные:: Это условие if, которое проверяет,
является ли текущий символ, который обрабатывается в цикле, одним
из символов, хранящихся в строке гласные.
6. количество_гласных += 1: Если текущий символ является
гласной буквой (соответствует условию if), то значение переменной
количество_гласных увеличивается на 1. Это выполняется для
подсчета количества гласных в строке.
7. print("Количество гласных букв в строке:",
количество_гласных): После завершения цикла, программа выводит
сообщение о количестве гласных букв в строке, используя значение
переменной количество_гласных.
Таким образом, этот код просит пользователя ввести строку, затем
анализирует каждый символ этой строки, и если символ является
гласной буквой, увеличивает счетчик количество_гласных. По
завершении анализа, он выводит количество найденных гласных
введенной строки.
 Глава 10: Словари и Множества
В предыдущих главах мы узнали много о том, как работать с
данными в Python. Мы научились хранить числа, строки и списки, но
иногда нам нужно что-то более сложное для решения задач. И здесь на
помощь приходят словари и множества.
Словари:
Словарь в Python – это структура данных, которая позволяет хранить
данные в формате ключ-значение. Ключ – это уникальное имя
элемента, а значение – это информация, связанная с этим ключом.
Давайте посмотрим на пример:
результаты_экзамена = {"Анна": 95, "Петя": 88, "Мария": 92}
В этом примере "Анна", "Петя" и "Мария" – это ключи, а числа 95,
88 и 92 – это значения, связанные с этими ключами. Теперь мы можем
легко получать оценки, обращаясь к словарю по имени:
print(результаты_экзамена["Анна"]) # Выводит 95
Мы также можем добавлять новые элементы в словарь или изменять
существующие:
результаты_экзамена["Андрей"] = 78 # Добавляем нового ученика
результаты_экзамена["Петя"] = 90 # Обновляем оценку Пети
Множества:
Множество – это структура данных, которая хранит уникальные
элементы без повторений. Она может быть полезной, когда вам нужно
отслеживать уникальные значения, например, в списке учеников без
повторений:
ученики = {"Анна", "Петя", "Мария", "Петя"}
В этом примере, несмотря на то, что "Петя" перечислен дважды,
множество будет хранить только одну копию:
print(ученики) # Выводит {'Петя', 'Мария', 'Анна'}
Множества также поддерживают операции объединения,
пересечения и разности, что делает их мощным инструментом для
решения задач.
Чем это полезно:
Использование словарей и множеств может значительно упростить
решение различных задач. Вы можете хранить данные в удобном
формате и быстро получать к ним доступ. Например, вы можете
использовать словарь для создания игр, в которых нужно отслеживать
счет игроков, или множество для анализа уникальных слов в тексте.
Практический пример:
Давайте создадим словарь для отслеживания количества слов в
тексте:
текст = "Это пример текста. Мы будем считать слова в этом
тексте."
слова = текст.split() # Разделяем текст на слова
словарь = {} # Создаем пустой словарь для подсчета слов

for слово in слова:

....if слово in словарь:
........словарь[слово] += 1
....else:
........словарь[слово] = 1

print(словарь)
1. текст = "Это пример текста. Мы будем считать слова в этом
тексте."

Здесь мы создаем строковую переменную текст, в которой хранится

некоторый текст, который мы будем анализировать.
2. слова = текст.split()

Мы используем метод split() для разделения строки текст на

отдельные слова. Этот метод разбивает строку на части, используя
пробелы в качестве разделителей, и возвращает список слов. После
выполнения этой строки, слова будет содержать список слов из текста.
3. словарь = {}

Здесь мы создаем пустой словарь словарь, который будет

использоваться для подсчета количества вхождений каждого слова.
4. for слово in слова:

Начинается цикл for, который будет перебирать каждое слово из

списка слова.
 5. if слово in словарь:

Здесь мы проверяем, есть ли текущее слово (слово) уже в словаре

словарь.
6. словарь[слово] += 1

Если слово уже есть в словаре словарь, то мы увеличиваем

соответствующее значение (частоту) этого слова на 1. Если это слово
уже встречалось ранее, у нас будет аккуратно подсчитано, сколько раз
оно встретилось.
7. else:

Если текущее слово не найдено в словаре словарь, мы попадаем в

эту ветвь.
8. словарь[слово] = 1

Здесь мы добавляем новое слово в словарь словарь и устанавливаем

его частоту равной 1, так как это первое вхождение данного слова.
9. print(словарь)

После завершения цикла, этот оператор выводит на экран

содержимое словаря словарь, который теперь содержит количество
вхождений каждого слова в тексте.
Итак, данный код выполняет анализ текста, подсчитывая, сколько
раз каждое слово встречается в тексте, и выводит результат на экран.
Этот код подсчитает, сколько раз каждое слово встречается в тексте.
Словари и множества – это мощные инструменты, которые помогут
вам решать различные задачи в программировании. Не бойтесь
экспериментировать и использовать их в ваших проектах!
 Глава 11: Файлы и Ввод/Вывод
Добро пожаловать в увлекательный мир работы с файлами и вводом/
выводом в Python! В этой главе мы узнаем, как программы могут
взаимодействовать с файлами на компьютере и как пользователи могут
взаимодействовать с программами через консоль.
Работа с файлами
Python предоставляет простые и мощные средства для работы с
файлами. Сначала давайте научимся открывать файлы. Вы можете
открыть файл с помощью функции open() и указать имя файла и
режим доступа.
# Открытие файла для чтения
file = open("example.txt", "r")

# Открытие файла для записи (создаст новый файл, если он не

существует)
file = open("output.txt", "w")
После открытия файла, вы можете читать его содержимое или
записывать в него данные.
# Чтение содержимого файла
content = file.read()
print(content)

# Запись данных в файл

file.write("Новые данные\n")
Не забывайте закрывать файл после окончания работы с ним.
file.close()
Используйте оператор with, чтобы автоматически закрыть файл
после выполнения операций:
with open("example.txt", "r") as file:
....content = file.read()
....print(content) # Файл будет автоматически закрыт после
выполнения блока кода
Ввод и вывод через консоль
 Python также позволяет взаимодействовать с программой через
консоль. Вы можете использовать функцию input(), чтобы получить
ввод от пользователя:
name = input("Введите ваше имя: ")
print(f"Привет, {name}!")
1. name = input("Введите ваше имя: "): Эта строка запрашивает у
пользователя ввод с клавиатуры. Функция input() выводит на экран
текст, указанный в скобках ("Введите ваше имя: "), и ожидает ввода от
пользователя. Введенные данные будут сохранены в переменной name.
2. print(f"Привет, {name}!"): В этой строке мы используем строку-
форматирование (f-строку). В фигурных скобках {} можно вставить
значение переменной name. Таким образом, программа выведет
приветствие, содержащее имя пользователя, которое было введено
ранее.
Пример: Если пользователь ввел "Иван", то программа выведет
"Привет, Иван!".
Таким образом, этот небольшой код позволяет программе
взаимодействовать с пользователем, запрашивать его имя и затем
выводить приветствие с использованием введенного имени.
Это простой способ создать интерактивные программы, которые
могут общаться с пользователем.
Чтобы отправить данные в консоль, используйте функцию print():
print("Привет, мир!")
Вы можете выводить переменные, комбинировать строки и числа в
один вывод и даже форматировать вывод с помощью метода .format().
age = 12
print("Мне {} лет.".format(age))

1. age = 12: В этой строке создается переменная age и ей

присваивается значение 12. Это означает, что у нас есть переменная с
именем age, которая содержит число 12. Мы используем эту
переменную для хранения возраста.
2. print("Мне {} лет.".format(age)): Это строка, которая выполняет
вывод текста на экран. Внутри строки есть фигурные скобки {},
которые будут заменены на значение переменной age в процессе
выполнения программы. Функция format() используется для
подстановки значения age вместо скобок. Таким образом, если age
равно 12, то на экран будет выведено "Мне 12 лет.".
Этот код демонстрирует пример форматирования строк в Python,
которое позволяет вставлять переменные в текстовые строки для
создания более динамичных сообщений.
Работа с файлами и вводом/выводом – это важные навыки в
программировании. Они позволяют вашим программам сохранять и
загружать данные, а также взаимодействовать с пользователем. Не
забывайте об управлении файлами и безопасности при работе с ними,
а также о том, что пользовательский ввод может быть разнообразным,
поэтому важно обрабатывать его аккуратно.
 Глава 12: Модули и Библиотеки
Ранее мы изучили, как создавать свои собственные функции и
структуры данных. Но что, если вам нужны дополнительные
инструменты или функции, которых нет в стандартной библиотеке
Python? Здесь на помощь приходят модули и библиотеки.
Что такое модуль?
Модуль – это файл с Python-кодом, который содержит функции,
переменные и классы, которые можно использовать в ваших
программах. Модули полезны, потому что они помогают организовать
код и делают его более читаемым и переиспользуемым.
Например, представьте себе, что вам нужно выполнить сложные
математические вычисления. Вместо того чтобы писать каждый раз
одни и те же функции, вы можете использовать модуль math,
встроенный в Python, который предоставляет множество
математических функций.
Импорт модулей
Для использования модулей в вашей программе, вам нужно их
импортировать. Вот как это делается:
import math

# Теперь мы можем использовать функции из модуля math

print(math.sqrt(25)) # Выведет квадратный корень числа 25
Если вам нужна только одна конкретная функция или переменная из
модуля, вы можете импортировать только ее, чтобы не загромождать
ваш код:
from math import sqrt

# Теперь мы можем использовать sqrt напрямую

print(sqrt(25))
Популярные библиотеки
Помимо стандартной библиотеки Python, существует огромное
количество сторонних библиотек, которые добавляют новые
возможности и функциональность. Вот некоторые из них:
 1. TensorFlow и PyTorch: Эти библиотеки используются для
машинного обучения и глубокого обучения. Они позволяют создавать
и обучать нейронные сети, что делает их идеальными для разработки
искусственного интеллекта и анализа данных.
2. Django и Flask: Django и Flask – это библиотеки для создания веб-
приложений. Django предоставляет более полноценный фреймворк для
больших веб-приложений, в то время как Flask предоставляет
минималистичный подход для создания небольших и средних веб-
приложений.
3. SQLAlchemy: Эта библиотека позволяет вам взаимодействовать с
базами данных, используя Python. Она предоставляет объектно-
реляционный маппинг (ORM), который упрощает работу с базами
данных.
4. Matplotlib и Seaborn: Эти библиотеки используются для создания
графиков и визуализации данных. Они полезны при анализе данных и
визуализации результатов.
5. OpenCV: OpenCV – это библиотека компьютерного зрения,
которая позволяет обрабатывать изображения и видео. Она широко
используется в задачах обнаружения объектов, распознавания лиц и
многих других приложениях.
6. Beautiful Soup: Эта библиотека предназначена для парсинга
HTML и XML документов. Она очень полезна, когда вам нужно
извлечь информацию с веб-страниц.
7. Selenium: Selenium – это инструмент для автоматизации действий
в веб-браузерах. Он часто используется для тестирования веб-
приложений, но также может быть полезен в других сценариях
автоматизации.
8. Twisted: Twisted – это библиотека для асинхронного
программирования и создания сетевых приложений. Она особенно
полезна для создания серверов и клиентов, работающих с сетью.
9. Pillow: Pillow – это библиотека для обработки изображений. Она
предоставляет множество функций для редактирования и
манипулирования изображениями.
10. Cryptography: Эта библиотека предоставляет инструменты для
шифрования данных и обеспечения безопасности в ваших
приложениях.
 Это только небольшой набор библиотек, доступных для Python.
Python имеет активное сообщество разработчиков, поэтому всегда
можно найти подходящую библиотеку для почти любой задачи.
Использование модулей и библиотек позволяет вам быстро
расширять возможности вашей программы, не писать все с нуля. Они
делают программирование более эффективным и мощным. Не бойтесь
исследовать различные библиотеки и модули, чтобы узнать, какие из
них могут пригодиться в вашем проекте. Помните, что в Интернете
существует множество ресурсов и документации для каждой из них,
что делает процесс изучения Python ещё увлекательнее.
 Глава 13: Заключение и дальнейшие
шаги
Поздравляем, вы завершили свое путешествие по миру Python!
Теперь у вас есть навыки программирования, и вы можете создавать
свои собственные программы. Но это только начало вашего
увлекательного путешествия в мире технологий. Давайте обсудим, что
вы можете делать дальше и какие двери открываются перед вами.
1. Применение знаний
Теперь, когда вы овладели основами Python, пришло время
применить ваши навыки на практике. Python – это мощный
инструмент, который можно использовать в разных сферах. Вот
несколько способов, как вы можете использовать свои знания:
Веб-разработка: Вы можете изучить фреймворки для веб-
разработки на Python, такие как Django или Flask, и создать
собственные веб-приложения. Это может быть блог, интернет-магазин,
форум и многое другое.
Анализ данных и научные исследования: Python широко
используется в анализе данных и научных исследованиях. Вы можете
изучить библиотеки, такие как NumPy, pandas и Matplotlib, для работы
с данными и визуализации результатов.
Игровая разработка: Если вас интересует создание компьютерных
игр, Python также может быть полезен. Pygame – это библиотека для
разработки игр на Python, которая может помочь вам создать
собственные игры.
Автоматизация задач: Python может быть использован для
автоматизации рутинных задач на вашем компьютере. Вы можете
написать скрипты, которые будут выполнять задачи, такие как
сортировка и перемещение файлов, обработка данных или
автоматическая отправка электронных писем.
Искусственный интеллект и машинное обучение: Python
используется в машинном обучении и разработке искусственного
интеллекта. Вы можете изучить библиотеки, такие как TensorFlow и
scikit-learn, чтобы создавать модели машинного обучения и решать
сложные задачи.
 Разработка мобильных приложений: С помощью фреймворков,
таких как Kivy или BeeWare, вы можете использовать Python для
создания мобильных приложений для Android и iOS.
Разработка роботов и автоматизированных систем: Python часто
используется в разработке программного обеспечения для роботов и
автоматизированных систем. Это может быть увлекательной областью,
если вас интересует робототехника.
Не бойтесь экспериментировать и пробовать новые вещи.
Программирование – это искусство решения проблем, и чем больше
задач вы будете решать с помощью Python, тем опытнее вы станете.
Удачи в ваших проектах!
2. Углубленное изучение
Поздравляем вас с освоением основ Python! Теперь, если вы готовы
погрузиться глубже в мир программирования, вот некоторые области, в
которых вы можете углубить свои знания:
Алгоритмы и структуры данных: Изучение алгоритмов и
структур данных поможет вам разрабатывать более эффективные
программы. Вы можете изучить такие концепции, как сортировка,
поиск и графы, и применять их в решении сложных задач.
Объектно-ориентированное программирование (ООП): ООП –
это методология программирования, которая позволяет
структурировать ваш код в виде объектов и классов. Изучение ООП
поможет вам создавать более организованный и масштабируемый код.
Работа с базами данных: Изучение работы с базами данных
позволит вам хранить и управлять большими объемами данных. Вы
можете изучить SQL для работы с реляционными базами данных или
NoSQL для работы с нереляционными данными.
Многозадачность и потоки: Изучение многозадачности позволит
вам создавать программы, которые могут выполнять несколько задач
одновременно. Python предоставляет множество инструментов для
работы с потоками и процессами.
Тестирование и отладка: Изучение методов тестирования и
отладки поможет вам создавать более надежные программы. Вы
можете изучить библиотеки и инструменты, такие как PyTest и pdb.
Web-разработка: Если вас интересует веб-разработка, вы можете
изучить фреймворки, такие как Django, для создания мощных веб-
приложений.
 Искусственный интеллект и машинное обучение: Изучение
машинного обучения и искусственного интеллекта поможет вам
создавать интеллектуальные приложения и алгоритмы.
Интернет вещей (IoT): Если вас интересует IoT, вы можете
изучить, как использовать Python для управления устройствами и
сенсорами.
Разработка игр: Если вы мечтаете создавать компьютерные игры,
изучение фреймворков и библиотек для разработки игр может быть
увлекательным занятием.
Выберите область, которая вас наиболее привлекает, и начните
глубже изучать ее. Программирование – это непрерывный процесс
обучения, и у вас есть возможность стать настоящим мастером в своей
области. Не забывайте практиковаться, решая реальные задачи, и у вас
получится достичь выдающихся результатов в мире
программирования!
2. Углубленное изучение
Поздравляем вас с освоением основ Python! Теперь, если вы готовы
погрузиться глубже в мир программирования, вот некоторые области, в
которых вы можете углубить свои знания:
Алгоритмы и структуры данных: Изучение алгоритмов и
структур данных поможет вам разрабатывать более эффективные
программы. Вы можете изучить такие концепции, как сортировка,
поиск и графы, и применять их в решении сложных задач.
Объектно-ориентированное программирование (ООП): ООП –
это методология программирования, которая позволяет
структурировать ваш код в виде объектов и классов. Изучение ООП
поможет вам создавать более организованный и масштабируемый код.
Работа с базами данных: Изучение работы с базами данных
позволит вам хранить и управлять большими объемами данных. Вы
можете изучить SQL для работы с реляционными базами данных или
NoSQL для работы с нереляционными данными.
Многозадачность и потоки: Изучение многозадачности позволит
вам создавать программы, которые могут выполнять несколько задач
одновременно. Python предоставляет множество инструментов для
работы с потоками и процессами.
Тестирование и отладка: Изучение методов тестирования и
отладки поможет вам создавать более надежные программы. Вы
можете изучить библиотеки и инструменты, такие как PyTest и pdb.
Web-разработка: Если вас интересует веб-разработка, вы можете
изучить фреймворки, такие как Django, для создания мощных веб-
приложений.
Искусственный интеллект и машинное обучение: Изучение
машинного обучения и искусственного интеллекта поможет вам
создавать интеллектуальные приложения и алгоритмы.
Интернет вещей (IoT): Если вас интересует IoT, вы можете
изучить, как использовать Python для управления устройствами и
сенсорами.
Разработка игр: Если вы мечтаете создавать компьютерные игры,
изучение фреймворков и библиотек для разработки игр может быть
увлекательным занятием.
Выберите область, которая вас наиболее привлекает, и начните
глубже изучать ее. Программирование – это непрерывный процесс
обучения, и у вас есть возможность стать настоящим мастером в своей
области. Не забывайте практиковаться, решая реальные задачи, и у вас
получится достичь выдающихся результатов в мире
программирования!
4. Решение задач и участие в проектах
Решение задач и участие в проектах – это отличный способ
применить свои знания в программировании на практике и научиться
создавать реальные приложения. Вот как это можно сделать:
Онлайн-платформы для решения задач:
• LeetCode (leetcode.com): LeetCode предоставляет множество задач
по алгоритмам и структурам данных, которые могут помочь вам
развить навыки программирования. Вы можете решать задачи на
Python и учиться оптимизировать свой код.
• HackerRank (hackerrank.com): HackerRank также предлагает
задачи по программированию и алгоритмам, а также соревнования, в
которых вы можете участвовать.
Open Source проекты:
Присоединение к проектам с открытым исходным кодом – это
отличный способ получить опыт и научиться работать в команде. Вы
можете найти проекты на GitHub, которые вас интересуют, и
предложить свою помощь. Ваш вклад может быть в виде написания
кода, исправления ошибок или создания документации.
 Создание собственных проектов:
Создание своих собственных проектов – это отличный способ
применить свои навыки. Придумайте интересный проект, который вас
мотивирует, и начните его разрабатывать. Это может быть веб-
приложение, мобильное приложение, игра или любое другое
приложение, которое вас интересует.
Соревнования по программированию:
Участие в соревнованиях по программированию, таких как ACM
ICPC, Codeforces или Google Code Jam, может помочь вам повысить
свой уровень навыков и решать сложные задачи.
Учебные проекты:
Если вы учитесь на курсах по программированию, многие из них
предлагают учебные проекты. Участвуйте активно в этих проектах, так
как они помогут вам закрепить вашу теорию на практике.
Практические задачи:
Попробуйте решать практические задачи, связанные с вашими
интересами. Например, если вас интересует веб-разработка, создайте
свой собственный блог или портфолио сайт.
Коллеги и сотрудничество:
Сотрудничество с другими программистами может быть очень
полезным. Обсуждайте проблемы, обменивайтесь знаниями и
создавайте проекты вместе.
Не бойтесь начинать с чего-то маленького и постепенно увеличивать
сложность ваших проектов. Регулярная практика и решение задач
помогут вам стать опытным программистом и добиться успеха в мире
программирования.
5. Путешествие в мир информатики
Информатика – это увлекательное и многогранное поле знаний,
которое выходит далеко за рамки простого программирования. Если
вы хотите погрузиться в мир информатики и исследовать его глубины,
вот как это можно сделать:
Теория информации:
Изучите основы теории информации. Это раздел информатики,
который занимается измерением, передачей и хранением информации.
Вы можете начать с книги Клода Шеннона "Математическая теория
связи", чтобы понять основные концепции.
Машинное обучение и искусственный интеллект:
 Познакомьтесь с машинным обучением и искусственным
интеллектом. Это одна из наиболее актуальных областей информатики.
Изучите алгоритмы машинного обучения, библиотеки, такие как
TensorFlow и PyTorch, и начните создавать модели искусственного
интеллекта.
Базы данных и хранение данных:
Изучите принципы работы баз данных и способы хранения и
обработки данных. Это важные навыки, которые пригодятся вам в
разработке приложений и анализе данных.
Компьютерные сети и безопасность:
Погрузитесь в мир компьютерных сетей и кибербезопасности.
Изучите принципы работы сетей, протоколы и методы обеспечения
безопасности данных.
Теория алгоритмов и вычислительная сложность:
Изучите алгоритмы и структуры данных в глубину. Понимание того,
как работают алгоритмы, и оценка их вычислительной сложности
являются важными навыками для оптимизации кода.
Квантовая информатика:
Познакомьтесь с основами квантовой информатики, которая
исследует использование квантовых явлений в области информации и
вычислений. Это одно из самых перспективных направлений в
информатике.
Интернет вещей (IoT):
Узнайте, как работает IoT и как создавать приложения и устройства
для подключенных вещей. Это включает в себя работу с датчиками,
микроконтроллерами и сетями.
Робототехника:
Изучите робототехнику и создание роботов. Это увлекательное
направление информатики, которое объединяет множество дисциплин,
включая механику, электронику и программирование.
Исследования и научные работы:
Если вы увлекаетесь информатикой, рассмотрите возможность
участия в научных исследованиях или написания научных статей. Это
позволит вам внести свой вклад в развитие области.
Путешествие в мир информатики – это бесконечное приключение, и
вы можете выбрать направление, которое вас наиболее увлекает. Не
бойтесь исследовать новые области и глубже погружаться в
информатическую науку.
6. Никогда не переставайте учиться
Один из ключевых принципов успешной карьеры в мире
информатики и программирования – это постоянное обучение и
самосовершенствование. Никогда не останавливайтесь на
достигнутом, и вас ждут новые горизонты и возможности. Вот как вы
можете продолжать учиться:
Следите за новостями и трендами:
Информатика и технологии меняются быстро. Подписывайтесь на
блоги, новостные ресурсы, ищите информацию о последних
технологических трендах и достижениях.
Обучение в течение жизни:
Возьмите на вооружение принцип обучения в течение жизни. Это
означает, что вы должны регулярно брать курсы, читать книги, учиться
новым языкам программирования и технологиям.
Участие в мероприятиях и конференциях:
Посещайте технические конференции, митапы и вебинары. Это
отличные места для обмена опытом, знакомства с экспертами и
изучения новых технологий.
Сертификация и дипломы:
Рассмотрите возможность получения сертификатов или
дополнительного образования, чтобы подтвердить ваши навыки и
знания. Сертификаты могут быть особенно полезными, если вы ищете
работу или повышение.
Проекты и практика:
Применяйте свои знания на практике. Создавайте проекты,
участвуйте в соревнованиях, работайте над открытыми исходными
кодами. Работа над реальными задачами углубит ваши навыки.
Обучение от опытных профессионалов:
Ищите наставников и менторов. Опытные программисты и
инженеры могут поделиться своими знаниями и опытом, что позволит
вам быстрее развиваться.
Широкий кругозор:
Не ограничивайтесь только программированием. Изучайте
связанные области, такие как дизайн, управление проектами, бизнес и
другие. Это поможет вам понимать задачи более широкого контекста.
 Профессиональное сообщество:
Присоединяйтесь к профессиональным сообществам, форумам и
социальным сетям, где обсуждаются технические темы. Общение с
коллегами и обмен опытом помогут вам учиться.
Не забывайте, что процесс обучения – это долгосрочное и
увлекательное путешествие. Никогда не переставайте учиться, и вы
всегда будете востребованным и успешным профессионалом в мире
информатики и программирования.