You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1454 lines
37 KiB
1454 lines
37 KiB
---
|
|
title: Учебник Python v 1.3
|
|
excerpt: Дополнительные задачи соедней сложности
|
|
date: '2023-10-17'
|
|
tags:
|
|
- Информатика
|
|
- Программирование
|
|
- Python
|
|
- Задачи
|
|
---
|
|
|
|
<TableOfContents>
|
|
|
|
- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
|
|
- [2. Операторы в Python](#2-операторы-в-python)
|
|
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
|
|
- [4. Цикл for в Python](#4-цикл-for-в-python)
|
|
|
|
</TableOfContents>
|
|
|
|
## 1. Ввод и вывод данных в Python
|
|
|
|
Переменная - это именованный контейнер для заданного значения.
|
|
|
|
```python
|
|
|
|
# Пример создания переменных
|
|
age = 19
|
|
name = 'Ivan'
|
|
isActive = True
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
name = 'Petr'
|
|
Name = 'Ivan'
|
|
|
|
# name и Name - это разные переменные
|
|
|
|
```
|
|
|
|
```python
|
|
# Имена переменных не могут начинаться с цифры!
|
|
```
|
|
|
|
В Python есть 4 примитивных типа данных:
|
|
|
|
```python
|
|
|
|
# int (целые числа)
|
|
age = 18
|
|
|
|
# float (дробные числа)
|
|
fraction = 2.5
|
|
|
|
# str (строки)
|
|
fruit = 'apple'
|
|
|
|
# bool (правда или ложь)
|
|
isReady = True # всего два значения: True и False
|
|
|
|
```
|
|
Мы можем преобразовывать один тип данных в другой с помощью одноименных функций. Например, число может стать строкой, строка - числом, дробное число - целым.
|
|
|
|
```python
|
|
|
|
age = '22' # str -> '22'
|
|
age = int(age) # int -> 22
|
|
age = float(age) # float -> 22.0
|
|
age = bool(age) # bool -> True
|
|
|
|
```
|
|
|
|
Функция print() выводит данные на экран.
|
|
|
|
```python
|
|
|
|
name = 'Alexey'
|
|
# В скобках записываются переданные в функцию параметры
|
|
print(name)
|
|
|
|
```
|
|
|
|
|
|
```python
|
|
|
|
# Вывод
|
|
>> Alexey
|
|
|
|
```
|
|
|
|
Функция print() может принимать несколько входных параметров.
|
|
|
|
```python
|
|
|
|
print(1, 2, 3)
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Вывод
|
|
>> 1 2 3
|
|
|
|
```
|
|
|
|
Каждый print() выводит данные на новой строке. По умолчанию завершающий символ строки равен символу новой строки (\n).
|
|
|
|
```python
|
|
|
|
print('Hello')
|
|
print('world')
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Вывод
|
|
>> Hello
|
|
>> world
|
|
|
|
```
|
|
|
|
Завершающий символ строки в функции print() можно изменять.
|
|
|
|
```python
|
|
|
|
print('Hello', end=' ')
|
|
print('world')
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Вывод
|
|
>> Hello world
|
|
|
|
```
|
|
|
|
Функция input() принимает пользовательский ввод данных.
|
|
|
|
```python
|
|
|
|
name = input()
|
|
print('Hello ' + name)
|
|
# После запуска скрипта Python будет ожидать ввода данных
|
|
|
|
```
|
|
|
|
Функция input может принимать всего лишь один аргумент - строку, которая выведется перед входной строкой.
|
|
|
|
```python
|
|
|
|
name = input('Enter your name: ')
|
|
print('Hello, ' + name)
|
|
|
|
```
|
|
|
|
Данные, полученные с помощью функции input(), имеют строковый тип данных (str).
|
|
|
|
Строки можно складывать друг с другом, такое сложение называется их конкатенацией или объединением.
|
|
|
|
|
|
```python
|
|
|
|
# Сумма двух строчных чисел
|
|
number1 = input('Введите число: ')
|
|
number2 = input('Введите число: ')
|
|
print(number1 + number2)
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 2
|
|
# Вывод:
|
|
>> 12
|
|
|
|
```
|
|
|
|
Преобразуем строковый тип в целое число (str -> int).
|
|
|
|
```python
|
|
# Исправленная сумма двух чисел
|
|
number1 = int(input('Введите число: '))
|
|
number2 = int(input('Введите число: '))
|
|
print(number1 + number2)
|
|
```
|
|
|
|
```python
|
|
# Ввод:
|
|
>> 1
|
|
>> 2
|
|
# Вывод:
|
|
>> 3
|
|
```
|
|
|
|
## Примеры
|
|
|
|
1. Произведение
|
|
|
|
|
|
```python
|
|
|
|
# Произведение двух введенных чисел
|
|
a = int(input('Введите число: '))
|
|
b = int(input('Введите число: '))
|
|
print(a * b)
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Ввод:
|
|
>> 4
|
|
>> 3
|
|
# Вывод:
|
|
>> 12
|
|
|
|
```
|
|
|
|
2. Приветствие
|
|
|
|
```python
|
|
|
|
# Приветствие пользователя по его имени
|
|
firstname = input('Введите свое имя: ') # здесь приводить к типу int не нужно
|
|
lastname = input('Введите свою фамилию: ')
|
|
print('Здравствуйте, ' + firstname + ' ' + lastname) # не забудьте про пробел между словами
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Ввод:
|
|
>> Иван
|
|
>> Иванов
|
|
# Вывод:
|
|
>> Здравствуйте, Иван Иванов
|
|
|
|
```
|
|
|
|
3. Остаток
|
|
|
|
```python
|
|
|
|
# Операция % позволяет получить остаток от деления
|
|
print(10 % 2) # 0, так как 10 делится на 2 нацело
|
|
print(10 % 3) # 1, остаток равен 1
|
|
print(10 % 4) # 2, остаток равен 2
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Вывод:
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
|
|
```
|
|
|
|
4. Деление нацело
|
|
|
|
```python
|
|
|
|
# Операция // позволяет получить целую часть от деления
|
|
print(10 // 2) # 5
|
|
print(10 // 3) # 3
|
|
print(10 // 4) # 2
|
|
|
|
```
|
|
|
|
```python
|
|
|
|
# Вывод:
|
|
>> 5
|
|
>> 3
|
|
>> 2
|
|
|
|
```
|
|
|
|
## Решение задач
|
|
|
|
1. Сумма трех
|
|
Посчитайте сумму трех введенных целых чисел
|
|
|
|
2. Площадь
|
|
Пользователь вводит стороны прямоугольника, выведите его площадь
|
|
|
|
3. Периметр
|
|
Пользователь вводит стороны прямоугольника, выведите его периметр
|
|
|
|
4. Площадь круга
|
|
Пользователь вводит радиус круга, выведите площадь круга
|
|
|
|
```python
|
|
|
|
# Ввод:
|
|
>> 2
|
|
# Вывод:
|
|
>> 12.56
|
|
|
|
```
|
|
5. Сумма дробных
|
|
Посчитайте сумму трех введенных дробных чисел.
|
|
|
|
```python
|
|
|
|
# Ввод:
|
|
>> 1.5
|
|
>> 2.5
|
|
>> 1.1
|
|
# Вывод:
|
|
>> 5.1
|
|
|
|
```
|
|
6. Школьники и яблоки
|
|
n школьников делят k яблок поровну, неделящийся остаток остается в корзинке. Сколько яблок достанется каждому школьнику? Сколько яблок останется в корзинке?
|
|
|
|
```python
|
|
# Ввод:
|
|
>> 10
|
|
>> 3
|
|
# Вывод:
|
|
>> 3 # каждому
|
|
>> 1 # останется
|
|
```
|
|
|
|
<TableOfContents>
|
|
|
|
- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
|
|
- [2. Операторы в Python](#2-операторы-в-python)
|
|
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
|
|
- [4. Цикл for в Python](#4-цикл-for-в-python)
|
|
|
|
|
|
</TableOfContents>
|
|
|
|
|
|
## 2. Операторы в Python
|
|
|
|
В языке программирования Python есть арифметические, логические и операторы сравнения.
|
|
|
|
Сложение:
|
|
|
|
```python
|
|
# Cложение
|
|
print(10 + 30)
|
|
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 40
|
|
```
|
|
Вычитание:
|
|
```python
|
|
# Вычитание
|
|
print(30 - 20)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 10
|
|
```
|
|
Умножение:
|
|
```python
|
|
# Умножение
|
|
print(2 * 9)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 18
|
|
```
|
|
Деление:
|
|
```python
|
|
# Деление
|
|
print(100 / 25)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 4
|
|
```
|
|
Кроме всем знакомой четверки есть и несколько экзотических операторов: взятие остатка от деления, деление нацело, возведение в степень.
|
|
|
|
Взятие остатка от деления:
|
|
```python
|
|
# Взятие остатка от деления на 2
|
|
print(0 % 2)
|
|
print(1 % 2)
|
|
print(2 % 2)
|
|
print(3 % 2)
|
|
print(4 % 2)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 0 # 0 % 2
|
|
>> 1 # 1 % 2
|
|
>> 0 # 2 % 2
|
|
>> 1 # 3 % 2
|
|
>> 0 # 4 % 2
|
|
```
|
|
```python
|
|
# Взятие остатка от деления на 3
|
|
print(0 % 3)
|
|
print(1 % 3)
|
|
print(2 % 3)
|
|
print(3 % 3)
|
|
print(4 % 3)
|
|
print(5 % 3)
|
|
print(6 % 3)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 0 # 0 % 3
|
|
>> 1 # 1 % 3
|
|
>> 2 # 2 % 3
|
|
>> 0 # 3 % 3
|
|
>> 1 # 4 % 3
|
|
>> 2 # 5 % 3
|
|
>> 0 # 6 % 3
|
|
```
|
|
Деление нацело:
|
|
```python
|
|
# Деление нацело на 10
|
|
print(91 // 10)
|
|
print(85 // 10)
|
|
print(16 // 10)
|
|
print(8 // 10)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 9 # 91 // 10
|
|
>> 8 # 85 // 10
|
|
>> 1 # 16 // 10
|
|
>> 0 # 8 // 10
|
|
```
|
|
```python
|
|
# Деление нацело на 2
|
|
print(14 // 2)
|
|
print(15 // 2)
|
|
print(7 // 2)
|
|
print(6 // 2)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 7 # 14 // 2
|
|
>> 7 # 15 // 2
|
|
>> 3 # 7 // 2
|
|
>> 3 # 6 // 2
|
|
```
|
|
Возведение в степень:
|
|
```python
|
|
# Возведение в степень числа 2
|
|
print(2 ** 0) # 1
|
|
print(2 ** 1) # 2
|
|
print(2 ** 2) # 2 * 2
|
|
print(2 ** 3) # 2 * 2 * 2
|
|
print(2 ** 4) # 2 * 2 * 2 * 2
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> 1
|
|
>> 2
|
|
>> 4
|
|
>> 8
|
|
>> 16
|
|
```
|
|
Операторы сравнения (╮°-°)╮ могут возвращать всего два результата: True и False.
|
|
|
|
Оператор равенства == возвращает True, если числа равны, и False в противном случае.
|
|
```python
|
|
a = 10
|
|
b = 10
|
|
print(a == b)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> True
|
|
```
|
|
```python
|
|
a = 8
|
|
b = 7
|
|
print(a == b)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> False
|
|
```
|
|
|
|
Оператор неравенства != возвращает True, если числа не равны, и False в противном случае.
|
|
```python
|
|
a = 8
|
|
b = 7
|
|
print(a != b)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> True
|
|
```
|
|
Оператор больше > возвращает True, если первое число больше второго, и False в противном случае.
|
|
```python
|
|
a = 8
|
|
b = 7
|
|
print(a > b)
|
|
print(b > a)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> True # a > b
|
|
>> False # b > a
|
|
```
|
|
Оператор меньше < возвращает True, если первое число меньше второго, и False в противном случае.
|
|
```python
|
|
c = 100
|
|
d = 200
|
|
print(c < d)
|
|
print(d < c)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> True # c < d
|
|
>> False # d < c
|
|
|
|
# Оператор меньше или равно <= возвращает True, если первое число меньше второго или равно ему, и False в противном случае.
|
|
```
|
|
Оператор больше или равно >= возвращает True, если первое число больше второго или равно ему, и False в противном случае.
|
|
```python
|
|
c = 200
|
|
d = 200
|
|
print(c >= d)
|
|
print(d <= c)
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> True # c >= d
|
|
>> True # d <= c
|
|
```
|
|
Иногда требуются выполнение нескольких операторов сравнения сразу. Для таких целей существует оператор and (оператор логического умножения, конъюнкция).
|
|
```python
|
|
print(10 > 0 and 5 > 0)
|
|
print(10 % 2 == 0 and 12 % 2 == 0) # оба числа четные
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> True
|
|
>> True
|
|
```
|
|
Если хотя бы один из операторов равен False, то результат оператора будет равен False. Конъюкция истинна в том случае, когда все условия истинны.
|
|
```python
|
|
print(10 > 100 and 5 > 0 and 10 > 0) # False
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> False
|
|
```
|
|
Логическое сложение (дизъюнкция) или оператор or требует выполнения ХОТЯ БЫ одного условия.
|
|
```python
|
|
print(10 > 100 or 5 > 100 or 10 > 0) # True
|
|
print(1 == 0 or 2 == 0) # False, оба условия ложны
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> True
|
|
>> False
|
|
```
|
|
Последний из операторов - это оператор инверсии not. Оператор not изменяет (инвертирует) значение на противоположное.
|
|
```python
|
|
print(not False) # True
|
|
print(not True) # False
|
|
print(not 2 == 0) # True
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> True
|
|
>> False
|
|
>> True
|
|
```
|
|
Оператор not выполняется в приоритете.
|
|
```python
|
|
print(not 1 == 0 or 2 == 0) # True, значение первого условия инвертировано
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> True
|
|
```
|
|
Решение задач
|
|
1. Одинаковая четность
|
|
Даны два целых числа: A, B. Проверить истинность высказывания: "Числа A и B имеют одинаковую четность".
|
|
```python
|
|
# Ввод:
|
|
>> 0
|
|
>> 1
|
|
# Вывод:
|
|
>> False
|
|
|
|
# Ввод:
|
|
>> 2
|
|
>> 10
|
|
# Вывод:
|
|
>> True
|
|
```
|
|
|
|
2. Одно положительное
|
|
Даны три целых числа: A, B, C. Проверить истинность высказывания: "Хотя бы одно из чисел A, B, C положительное".
|
|
```python
|
|
# Ввод:
|
|
>> 0
|
|
>> -1
|
|
>> -10
|
|
# Вывод:
|
|
>> False
|
|
|
|
# Ввод:
|
|
>> -1
|
|
>> 1
|
|
>> 0
|
|
# Вывод:
|
|
>> True
|
|
```
|
|
3. Последняя цифра
|
|
Дано натуральное число. Выведите его последнюю цифру.
|
|
```python
|
|
# Ввод:
|
|
>> 2345678
|
|
# Вывод:
|
|
>> 8
|
|
|
|
# Ввод:
|
|
>> 19
|
|
# Вывод:
|
|
>> 9
|
|
```
|
|
4. Цифры двузначного
|
|
Дано двузначное число. Найдите сумму его цифр.
|
|
```python
|
|
# Ввод:
|
|
>> 22
|
|
# Вывод:
|
|
>> 4
|
|
|
|
# Ввод:
|
|
>> 99
|
|
# Вывод:
|
|
>> 18
|
|
```
|
|
5. Цифры трехзначного
|
|
Дано трехзначное число. Найдите сумму его цифр.
|
|
```python
|
|
# Ввод:
|
|
>>123
|
|
# Вывод:
|
|
>> 6
|
|
|
|
# Ввод:
|
|
>> 332
|
|
# Вывод:
|
|
>> 8
|
|
```
|
|
6. Разные цифры
|
|
Дано трехзначное число. Проверить истинность высказывания: "Все цифры данного числа различны".
|
|
```python
|
|
# Ввод:
|
|
>> 123
|
|
# Вывод:
|
|
>> True
|
|
|
|
# Ввод:
|
|
>> 332
|
|
# Вывод:
|
|
>> False
|
|
```
|
|
7. Часы (финальный босс)
|
|
С начала суток прошло N секунд (N - целое). Найти количество часов, минут и секунд на электронных часах.
|
|
```python
|
|
# Ввод:
|
|
>> 1000
|
|
# Вывод:
|
|
>> 0 16 40
|
|
|
|
# Ввод:
|
|
>> 10000
|
|
# Вывод:
|
|
>> 2 46 40
|
|
|
|
# Ввод:
|
|
>> 85001
|
|
# Вывод:
|
|
>> 23 36 41
|
|
```
|
|
|
|
<TableOfContents>
|
|
|
|
- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
|
|
- [2. Операторы в Python](#2-операторы-в-python)
|
|
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
|
|
- [4. Цикл for в Python](#4-цикл-for-в-python)
|
|
|
|
</TableOfContents>
|
|
|
|
## 3. Условный оператор в Python
|
|
|
|
Условный оператор выполняет некоторое действие, если указанное условие истинно (равно True).
|
|
|
|
```python
|
|
# Обратите внимание на отступ в четыре (4!) пробела
|
|
# или одну табуляцию (кнопочка TAB)
|
|
if True: # Обязательное двоеточие перед блоком кода
|
|
print('Условие истинно, поэтому я напечатаюсь')
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> Условие истинно, поэтому я напечатаюсь
|
|
```
|
|
В условии любой тип данных неявно приводится к bool. Пустая строка и ноль равны False.
|
|
```python
|
|
print(bool(1)) # -> True
|
|
print(bool(0)) # -> False
|
|
print(bool(10.2)) # -> True
|
|
print(bool('')) # -> False
|
|
print(bool('Hello')) # -> True
|
|
```
|
|
Если условие ложно, то код, находящийся под оператором if не выполнится.
|
|
```python
|
|
if 0: # Обязательное двоеточие перед блоком кода
|
|
print('Я никогда не напечатаюсь :(')
|
|
```
|
|
Если условие в if ложно, то выполнится оператор под оператором else.
|
|
```python
|
|
if 0:
|
|
print('Я никогда не напечатаюсь :(')
|
|
else:
|
|
print('Оператор else вступает в игру')
|
|
```
|
|
```python
|
|
# Вывод
|
|
>> Оператор else вступает в игру
|
|
```
|
|
Иногда двух вариантов недостаточно, для этого существует оператор elif, а для все остального есть...
|
|
```python
|
|
age = int(input())
|
|
if age < 10:
|
|
print('Ваш возраст - это одна цифра :)')
|
|
elif age < 15:
|
|
print('Удачи с геометрией :):):)')
|
|
else:
|
|
print('Совсем взрослый уже :(')
|
|
```
|
|
Если условие в операторе if ложно, то интерпретатор проверяет истинность условия операторов elif, всех по очереди. Если все условия ложны, то выполнится оператор else.
|
|
|
|
Примеры
|
|
1. Четное-нечетное
|
|
```python
|
|
# Выведите строку 'четное', если введенное число четно, и строку 'нечетное', если число нечетно.
|
|
a = int(input())
|
|
if a % 2 == 0:
|
|
print('четное')
|
|
else:
|
|
print('нечетное')
|
|
```
|
|
```python
|
|
# Ввод
|
|
>> 10
|
|
# Вывод
|
|
>> четное
|
|
|
|
# Ввод
|
|
>> 11
|
|
# Вывод
|
|
>> нечетное
|
|
```
|
|
2. Много elif'ов
|
|
```python
|
|
# Если в вашем коде больше трех elif значит что-то не так и стоит придумать новый алгоритм.
|
|
# Это сугубо академический пример, так писать не стоит.
|
|
a = int(input('Введите число от одного до 1 до 100'))
|
|
if a < 10:
|
|
print('Ваше число меньше 10')
|
|
elif a < 20:
|
|
print('Ваше число меньше двадцатки')
|
|
elif a < 30:
|
|
print('30 - это потолок')
|
|
elif a < 40:
|
|
print('Ваше число меньше 40')
|
|
elif a < 50:
|
|
print('Много, но не больше полтинника')
|
|
elif a < 60:
|
|
print('Число меньше, чем шесть*десять')
|
|
elif a < 70:
|
|
print('Ваше число расположено в восьмом десятке')
|
|
elif a < 80:
|
|
print('Ваше число меньше 80')
|
|
elif a < 90:
|
|
print('Ваше число находится в 9 десятке')
|
|
elif a < 100:
|
|
print('Сотня больше вашего числа')
|
|
else:
|
|
print('Хитро, но меня не обманешь, число слишком большое')
|
|
```
|
|
```python
|
|
# Ввод
|
|
>> 11
|
|
# Вывод
|
|
>> Ваше число меньше двадцатки
|
|
|
|
# Ввод
|
|
>> 91
|
|
# Вывод
|
|
>> Сотня больше вашего числа
|
|
|
|
# Ввод
|
|
>> 58
|
|
# Вывод
|
|
>> Число меньше, чем шесть*десять
|
|
```
|
|
|
|
3. Белая или черная
|
|
```python
|
|
# Пользователь вводит два числа: координаты шахматной клетки.
|
|
# Выведите YES, если клетка белая, и NO, если - черная.
|
|
|
|
x = int(input('Введите координату x: '))
|
|
y = int(input('Введите координату y: '))
|
|
# Идея такая: если четность координат совпадает,
|
|
# то это черная клетка, а если - нет, то белая.
|
|
|
|
if (x + y) % 2 == 1:
|
|
print('YES')
|
|
else:
|
|
print('NO')
|
|
```
|
|
```python
|
|
# Ввод:
|
|
>> 1
|
|
>> 1
|
|
# Вывод:
|
|
>> NO
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 1
|
|
# Вывод:
|
|
>> NO
|
|
```
|
|
4. Белая или черная (случайные координаты)
|
|
```python
|
|
# Та же задача, но со случайными числами.
|
|
# Координаты шахматной клетки выбираются случайным образом
|
|
# Выведите YES, если клетка белая, и NO, если - черная.
|
|
|
|
from random import randint # импортирование функции randint
|
|
x = randint(1,8) # функция randint вернет случайное число от 1 до 8
|
|
y = randint(1,8)
|
|
print(x, y) # вывод пары случайных чисел
|
|
|
|
if (x + y) % 2 == 1:
|
|
print('YES')
|
|
else:
|
|
print('NO')
|
|
```
|
|
Решение задач
|
|
1. Меньшее из двух
|
|
Пользователь вводит два целых числа. Выведите меньшее из них.
|
|
|
|
2. Четырехзначное?
|
|
Пользователь вводит целое число. Выведите YES, если это число является четырехзначным, и NO в противном случае.
|
|
|
|
3. Треугольник?
|
|
Треугольник существует только тогда, когда сумма любых двух его сторон больше третьей. Дано a, b, c - стороны предполагаемого треугольника. Требуется сравнить длину каждого отрезка-стороны с суммой двух других. Если хотя бы в одном случае отрезок окажется больше суммы двух других, то треугольника с такими сторонами не существует.
|
|
```python
|
|
# Ввод:
|
|
>> 3
|
|
>> 4
|
|
>> 5
|
|
# Вывод:
|
|
>> YES
|
|
|
|
# Ввод:
|
|
>> 3
|
|
>> 10
|
|
>> 5
|
|
# Вывод:
|
|
>> NO
|
|
```
|
|
4. Время суток
|
|
Пользователь вводит время в часах. Если введенное число находится между 5 и 11 часами включительно, выведите строку 'Утро'. Если число лежит в диапазоне от 12 до 17 часов включительно, выведите строку 'День'. Если число находится между 18 и 22, то выведите 'Вечер'. В случае поздней ночи (от 23 до 4 включительно) выведите 'Ночь'. В остальных случаях выведите строку 'Ошибка'.
|
|
```python
|
|
# Ввод:
|
|
>> 3
|
|
# Вывод:
|
|
>> Ночь
|
|
|
|
# Ввод:
|
|
>> 6
|
|
# Вывод:
|
|
>> Утро
|
|
|
|
# Ввод:
|
|
>> 13
|
|
# Вывод:
|
|
>> День
|
|
|
|
# Ввод:
|
|
>> 2020
|
|
# Вывод:
|
|
>> Ошибка
|
|
```
|
|
5. День недели
|
|
Пользователь вводит номер дня недели. Выведите строку 'Выходные', если введенное число равно 6 или 7. В случае, если число лежит в диапазоне от 1 до 5 включительно, выведите строку 'Будни'.
|
|
```python
|
|
# Ввод:
|
|
>> 3
|
|
# Вывод:
|
|
>> Будни
|
|
|
|
# Ввод:
|
|
>> 6
|
|
# Вывод:
|
|
>> Выходные
|
|
```
|
|
6. Описание числа
|
|
Пользователь вводит целое число. Выведите его строку-описание вида "отрицательное четное число", "ноль", "положительное нечетное число", например, численным описанием числа 190 является строка "положительное четное число".
|
|
|
|
```python
|
|
# Ввод:
|
|
>> 1
|
|
# Вывод:
|
|
>> положительное нечетное число
|
|
|
|
# Ввод:
|
|
>> 06
|
|
# Вывод:
|
|
>> отрицательное четное число
|
|
|
|
# Ввод:
|
|
>> 0
|
|
# Вывод:
|
|
>> ноль
|
|
|
|
# Ввод:
|
|
>> 2
|
|
# Вывод:
|
|
>> положительное четное число
|
|
```
|
|
7. Конь (финальный босс)
|
|
Шахматный конь ходит буквой "Г" - на две клетки по вертикали в любом направлении и на одну клетку по горизонтали, или наоборот. Даны две различные клетки шахматной доски, определите, может ли конь попасть с первой клетки на вторую одним ходом. В случае, если хотя бы одно из введенных чисел не лежит в диапазоне от 1 до 8, выведите строку "Ошибка!".
|
|
```python
|
|
# Ввод:
|
|
>> 1 # координата x1
|
|
>> 1 # координата y1
|
|
>> 2 # координата x2
|
|
>> 2 # координата y2
|
|
# Вывод:
|
|
>> NO
|
|
|
|
# Ввод:
|
|
>> 1 # координата x1
|
|
>> 1 # координата y1
|
|
>> 3 # координата x2
|
|
>> 2 # координата y2
|
|
# Вывод:
|
|
>> YES
|
|
|
|
# Ввод:
|
|
>> 3 # координата x1
|
|
>> 8 # координата y1
|
|
>> 2 # координата x2
|
|
>> 6 # координата y2
|
|
# Вывод:
|
|
>> YES
|
|
|
|
# Ввод:
|
|
>> 3 # координата x1
|
|
>> 4 # координата y1
|
|
>> 5 # координата x2
|
|
>> 6 # координата y2
|
|
# Вывод:
|
|
>> YES
|
|
```
|
|
|
|
<TableOfContents>
|
|
|
|
- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
|
|
- [2. Операторы в Python](#2-операторы-в-python)
|
|
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
|
|
- [4. Цикл for в Python](#4-цикл-for-в-python)
|
|
|
|
</TableOfContents>
|
|
|
|
## 4. Цикл for в Python
|
|
|
|
Цикл в любом языке программирования - это многократное выполнение одного и то же действия.
|
|
|
|
В Python все немного не так. Здесь цикл for - это цикл перебора последовательности. Он состоит из двух компонент: переменной (переменных) цикла и последовательности. Приведу пример:
|
|
```python
|
|
for item in 'one', 'two', 'three':
|
|
print(item)
|
|
```
|
|
В приведенном выше примере переменная цикла item по очереди принимает каждое значение последовательности, которая записана после служебного слова in. На первом повторении переменная item равна строке 'one', на втором - строке 'two', на третьем - строке 'three'.
|
|
```python
|
|
# Вывод:
|
|
>> one
|
|
>> two
|
|
>> three
|
|
```
|
|
Еще несколько примеров:
|
|
```python
|
|
for element in '1', 'hello', 2, 1990, True, False:
|
|
print(element)
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> 1
|
|
>> hello
|
|
>> 2
|
|
>> 1990
|
|
>> True
|
|
>> False
|
|
```
|
|
```python
|
|
for letter in 'Hello world':
|
|
print(letter)
|
|
```
|
|
```python
|
|
>> H
|
|
>> e
|
|
>> l
|
|
>> l
|
|
>> o
|
|
>>
|
|
>> w
|
|
>> o
|
|
>> r
|
|
>> l
|
|
>> d
|
|
```
|
|
Функция range()
|
|
|
|
Функция range() возвращает диапазон (последовательность) целых чисел. range() может принимать 1, 2 или 3 аргумента.
|
|
|
|
Примеры функции range() с одним аргументом:
|
|
```python
|
|
# range() с одним аргументом
|
|
|
|
print('range(3) -> 0, 1, 2')
|
|
for x in range(3): # range(3) -> 0, 1, 2
|
|
print(x)
|
|
|
|
print('range(5) -> 0, 1, 2, 3, 4')
|
|
for x in range(5): # range(5) -> 0, 1, 2, 3, 4
|
|
print(x)
|
|
|
|
# range(1) -> 0
|
|
# range(6) -> 0, 1, 2, 3, 4, 5
|
|
# range(10) -> 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> range(3) -> 0, 1, 2
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
>> range(5) -> 0, 1, 2, 3, 4
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
```
|
|
Примеры функции range() с двумя аргументами:
|
|
```python
|
|
print('range(3, 5) -> 3, 4')
|
|
for x in range(3, 5): # range(3, 5) -> 3, 4
|
|
print(x)
|
|
|
|
print('range(1, 5) -> 1, 2, 3, 4')
|
|
for x in range(1, 5): # range(1, 5) -> 1, 2, 3, 4
|
|
print(x)
|
|
|
|
# range(2, 7) -> 2, 3, 4, 5, 6
|
|
# range(100, 105) -> 100, 101, 102, 103, 104
|
|
# range(50, 53) -> 50, 51, 52
|
|
```
|
|
```python
|
|
# Вывод:
|
|
>> range(3, 5) -> 3, 4
|
|
>> 3
|
|
>> 4
|
|
>> range(1, 5) -> 1, 2, 3, 4
|
|
>> 1
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
```
|
|
Примеры функции range() с тремя аргументами:
|
|
```python
|
|
print('range(0, 10, 2) -> 0, 2, 4, 6, 8')
|
|
for x in range(0, 10, 2): # range(0, 10, 2) -> 0, 2, 4, 6, 8
|
|
print(x)
|
|
|
|
print('range(1, 10, 2) -> 1, 3, 5, 7, 9')
|
|
for x in range(1, 10, 2): # range(1, 10, 2) -> 1, 3, 5, 7, 9
|
|
print(x)
|
|
|
|
print('range(10, 20, 3) -> 10, 13, 16, 19')
|
|
for x in range(10, 20, 3): # range(10, 20, 3) -> 10, 13, 16, 19
|
|
print(x)
|
|
|
|
# range(2, 7, 5) -> 2
|
|
# range(1, 8, 4) -> 1, 5
|
|
# range(4, 20, 5) -> 4, 9, 14, 19
|
|
```
|
|
```python
|
|
>> range(0, 10, 2) -> 0, 2, 4, 6, 8
|
|
>> 0
|
|
>> 2
|
|
>> 4
|
|
>> 6
|
|
>> 8
|
|
>> range(1, 10, 2) -> 1, 3, 5, 7, 9
|
|
>> 1
|
|
>> 3
|
|
>> 5
|
|
>> 7
|
|
>> 9
|
|
>> range(10, 20, 3) -> 10, 13, 16, 19
|
|
>> 10
|
|
>> 13
|
|
>> 16
|
|
>> 19
|
|
```
|
|
Решение задач
|
|
1. Вывод чисел от 0 до N
|
|
Пользователь вводит число N. Выведите все числа от 0 до N включительно.
|
|
```python
|
|
# Ввод:
|
|
>> 4
|
|
# Вывод:
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
```
|
|
2. Вывод чисел от K до N
|
|
Пользователь вводит числа K и N. Выведите все числа от K до N включительно.
|
|
```python
|
|
# Ввод:
|
|
>> 2
|
|
>> 7
|
|
# Вывод:
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
>> 5
|
|
>> 6
|
|
>> 7
|
|
```
|
|
3. Сумма от K до N
|
|
Пользователь вводит числа K и N. Выведите сумму чисел от K до N включительно.
|
|
```python
|
|
# Ввод:
|
|
>> 1
|
|
>> 5
|
|
# Вывод:
|
|
>> 15
|
|
```
|
|
4. Сумма четных от K до N
|
|
Пользователь вводит числа K и N. Выведите сумму только четных чисел от K до N включительно.
|
|
```python
|
|
# Ввод:
|
|
>> 1
|
|
>> 5
|
|
# Вывод:
|
|
>> 6 # 2 + 4
|
|
```
|
|
5. Сумма дробей (часть первая)
|
|
Пользователь вводит число N. Найдите сумму чисел: 1 + 1.1 + 1.2 + 1.3 + ... + (1 + N / 10).
|
|
```python
|
|
# Ввод:
|
|
>> 5
|
|
# Вывод:
|
|
>> 7.5
|
|
```
|
|
6. Сумма дробей (часть вторая)
|
|
Пользователь вводит число N. Найдите сумму чисел: 1 + 1/2 + 1/3 + ... + 1/N
|
|
```python
|
|
# Ввод:
|
|
>> 5
|
|
# Вывод:
|
|
>> 2.283
|
|
```
|
|
Цикл while в Python
|
|
Назад в начало
|
|
Цикл while ("пока") позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается после ключевого слова while и проверяется до выполнения тела цикла.
|
|
|
|
Цикл while используется, когда невозможно определить точное количество повторений цикла.
|
|
|
|
i = 0 # объявление переменной i для условия цикла
|
|
while i < 5: # ключевое слово 'while' и условие выполнение цикла
|
|
# тело цикла
|
|
print(i) # вывод значения переменной i
|
|
i += 1 # увеличение значения переменной i на единицу
|
|
|
|
# Вывод:
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
|
|
Цикл while может быть бесконечным.
|
|
|
|
i = 0
|
|
while True: # условие всегда истинно
|
|
print(i)
|
|
i += 1
|
|
|
|
# Вывод:
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
...
|
|
>> 999
|
|
...
|
|
# Это может продолжаться долго...
|
|
|
|
Выполнение цикла можно прерывать с помощью оператора break.
|
|
|
|
i = 0
|
|
while 1: # условие всегда истинно
|
|
if i == 3: # если i равно 3, то вызываем оператор break
|
|
break # оператор break прерывает выполнение цикла
|
|
print(i)
|
|
i += 1
|
|
|
|
# Вывод:
|
|
>> 0
|
|
>> 1
|
|
>> 2
|
|
|
|
Оператор continue начинает повторение цикла заново.
|
|
|
|
i = 0
|
|
while i < 5:
|
|
i += 1 #
|
|
if i % 2 == 1: # если значение i нечетно, то вызываем оператор continue
|
|
continue # оператор continue начинает повторение цикла заново
|
|
# в случае вызова continue код ниже не выполнится
|
|
print(i)
|
|
|
|
# Вывод:
|
|
>> 0
|
|
>> 2
|
|
>> 4
|
|
|
|
Как и для цикла for, для цикла while мы можем записать конструкцию else.
|
|
|
|
x = 1
|
|
while x < 5:
|
|
print(x)
|
|
x += 1
|
|
else:
|
|
print('Цикл завершен')
|
|
|
|
# Вывод:
|
|
>> 1
|
|
>> 2
|
|
>> 3
|
|
>> 4
|
|
>> Цикл завершен
|
|
|
|
Примеры
|
|
1. Числа от A до B
|
|
# Пользователь вводит числа A и B (A > B). Выведите все числа от A до B включительно.
|
|
|
|
A = int(input('Введите число: '))
|
|
B = int(input('Введите число: '))
|
|
|
|
while A >= B:
|
|
print(A)
|
|
A -= 1
|
|
|
|
# Ввод:
|
|
>> 12
|
|
>> 7
|
|
# Вывод:
|
|
>> 12
|
|
>> 11
|
|
>> 10
|
|
>> 9
|
|
>> 8
|
|
>> 7
|
|
|
|
# Ввод:
|
|
>> 5
|
|
>> 2
|
|
# Вывод:
|
|
>> 5
|
|
>> 4
|
|
>> 3
|
|
>> 2
|
|
|
|
2. Много чисел
|
|
# Пользователь вводит числа до тех пор, пока не введет 0.
|
|
# Выведите количество введенных чисел (0 считать не нужно).
|
|
|
|
n = int(input('Введите число: '))
|
|
counter = 0 # счетчик введенных чисел
|
|
while n: # n неявно преобразуется в тип bool
|
|
# если n равно 0, то выполнение цикла прервется
|
|
n = int(input('Введите число: ')) # вводим очередное число
|
|
counter += 1 # увеличиваем счетчик
|
|
|
|
print(f'Количество чисел {counter}')
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 10
|
|
>> 100
|
|
>> 1000
|
|
>> 0
|
|
# Вывод:
|
|
>> Количество чисел 4
|
|
|
|
3. Наименьший делитель
|
|
# Пользователь вводит число N (N > 1). Выведите его наименьший делитель.
|
|
N = int(input('Введите число: '))
|
|
div = 2
|
|
|
|
while N % div != 0:
|
|
div += 1
|
|
print(f'Наименьший делитель равен {div}')
|
|
|
|
# Ввод:
|
|
>> 10
|
|
# Вывод:
|
|
>> Наименьший делитель равен 2
|
|
|
|
# Ввод:
|
|
>> 15
|
|
# Вывод:
|
|
>> Наименьший делитель равен 3
|
|
|
|
# Ввод:
|
|
>> 17
|
|
# Вывод:
|
|
>> Наименьший делитель равен 17
|
|
Решение задач
|
|
1. Четные от A до B
|
|
Пользователь вводит числа A и B (A > B). Выведите четные числа от A до B включительно.
|
|
|
|
# Ввод:
|
|
>> 10
|
|
>> 1
|
|
# Вывод:
|
|
>> 10
|
|
>> 8
|
|
>> 6
|
|
>> 4
|
|
>> 2
|
|
|
|
2. От A до B на три
|
|
Пользователь вводит числа A и B (A < B, A меньше B). Выведите числа от A до B включительно, которые делятся на три.
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 15
|
|
# Вывод:
|
|
>> 3
|
|
>> 6
|
|
>> 9
|
|
>> 12
|
|
>> 15
|
|
|
|
3. Сумма чисел
|
|
Пользователь вводит числа до тех пор, пока не введет 0. Выведите сумму введенных чисел (0 считать не нужно).
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 15
|
|
>> 10
|
|
>> 11
|
|
>> 2
|
|
>> 0
|
|
# Вывод:
|
|
>> Сумма равна: 39
|
|
|
|
4. Максимум
|
|
Пользователь вводит числа до тех пор, пока не введет 0. Выведите максимальное введенное число (0 считать не нужно).
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 15
|
|
>> 10
|
|
>> 11
|
|
>> 2
|
|
>> 0
|
|
# Вывод:
|
|
>> Максимум равен: 15
|
|
|
|
5. Минимум
|
|
Пользователь вводит числа до тех пор, пока не введет 0. Выведите минимальное введенное число (0 считать не нужно).
|
|
|
|
# Ввод:
|
|
>> 1
|
|
>> 15
|
|
>> 10
|
|
>> 11
|
|
>> 2
|
|
>> 0 # 0 не входит в последовательность
|
|
# Вывод:
|
|
>> Минимум равен: 1
|
|
|
|
6. Факториал
|
|
Пользователь вводит число N. Выведите факториал число N. Факториал числа N - это произведение всех чисел от 1 до N включительно. Например, факториал числа 5 равен 120.
|
|
|
|
# Ввод:
|
|
>> 5
|
|
# Вывод:
|
|
>> 120
|
|
|
|
# Ввод:
|
|
>> 3
|
|
# Вывод:
|
|
>> 6
|
|
|
|
# Ввод:
|
|
>> 4
|
|
# Вывод:
|
|
>> 24
|
|
7. Фибоначчи (финальный босс)
|
|
Пользователь вводит число N. Выведите N-ное по счету число Фибоначчи. Последовательность чисел Фибоначчи рассчитывается по такой формуле: F(1) = 1, F(2) = 1, F(K) = F(K-2) + F(K-1). Идея такая: каждое следующее число равно сумму двух предыдущих.
|
|
|
|
Первые 10 чисел последовательности: 1 1 2 3 5 8 13 21 34 55 ...
|
|
|
|
# Ввод:
|
|
>> 5
|
|
# Вывод:
|
|
>> 5
|
|
|
|
# Ввод:
|
|
>> 10
|
|
# Вывод:
|
|
>> 55
|
|
|
|
# Ввод:
|
|
>> 8
|
|
# Вывод:
|
|
>> 21 |