blog.krasnikov.pro/content/posts/textbook/python.mdx

---
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)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-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)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-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)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-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)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-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
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-python)

</TableOfContents>


## 5. Цикл while в Python

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

Цикл while используется, когда невозможно определить точное количество повторений цикла.

```python
i = 0 # объявление переменной i для условия цикла
while i < 5: # ключевое слово 'while' и условие выполнение цикла
    # тело цикла
    print(i) # вывод значения переменной i
    i += 1 # увеличение значения переменной i на единицу
```
```python
# Вывод:
>> 0
>> 1
>> 2
>> 3
>> 4
```
Цикл while может быть бесконечным.
```python
i = 0
while True: # условие всегда истинно
    print(i)
    i += 1
```
```python
# Вывод:
>> 0
>> 1
>> 2
>> 3
>> 4
...
>> 999
...
# Это может продолжаться долго...
```
Выполнение цикла можно прерывать с помощью оператора break.
```python
i = 0
while 1: # условие всегда истинно
    if i == 3: # если i равно 3, то вызываем оператор break
        break # оператор break прерывает выполнение цикла
    print(i)
    i += 1
```
```python
# Вывод:
>> 0
>> 1
>> 2
```
Оператор continue начинает повторение цикла заново.
```python
i = 0
while i < 5:
    i += 1 #
    if i % 2 == 1: # если значение i нечетно, то вызываем оператор continue
        continue # оператор continue начинает повторение цикла заново
    # в случае вызова continue код ниже не выполнится
    print(i)
```
```python
# Вывод:
>> 0
>> 2
>> 4
```
Как и для цикла for, для цикла while мы можем записать конструкцию else.
```python
x = 1
while x < 5:
    print(x)
    x += 1
else:
    print('Цикл завершен')
```
```python
# Вывод:
>> 1
>> 2
>> 3
>> 4
>> Цикл завершен
```
Примеры
1. Числа от A до B
```python
# Пользователь вводит числа A и B (A > B). Выведите все числа от A до B включительно.
A = int(input('Введите число: '))
B = int(input('Введите число: '))

while A >= B:
    print(A)
    A -= 1
```
```python
# Ввод:
>> 12
>> 7
# Вывод:
>> 12
>> 11
>> 10
>> 9
>> 8
>> 7

# Ввод:
>> 5
>> 2
# Вывод:
>> 5
>> 4
>> 3
>> 2
```
2. Много чисел
```python
# Пользователь вводит числа до тех пор, пока не введет 0.
# Выведите количество введенных чисел (0 считать не нужно).
n = int(input('Введите число: '))
counter = 0 # счетчик введенных чисел
while n: # n неявно преобразуется в тип bool
    # если n равно 0, то выполнение цикла прервется
    n = int(input('Введите число: ')) # вводим очередное число
    counter += 1 # увеличиваем счетчик

print(f'Количество чисел {counter}')
```
```python
# Ввод:
>> 1
>> 10
>> 100
>> 1000
>> 0
# Вывод:
>> Количество чисел 4
```
3. Наименьший делитель
```python
# Пользователь вводит число N (N > 1). Выведите его наименьший делитель.
N = int(input('Введите число: '))
div = 2

while N % div != 0:
    div += 1
print(f'Наименьший делитель равен {div}')
```
```python
# Ввод:
>> 10
# Вывод:
>> Наименьший делитель равен 2
```
```python
# Ввод:
>> 15
# Вывод:
>> Наименьший делитель равен 3
```
```python
# Ввод:
>> 17
# Вывод:
>> Наименьший делитель равен 17
```
Решение задач
1. Четные от A до B
Пользователь вводит числа A и B (A > B). Выведите четные числа от A до B включительно.
```python
# Ввод:
>> 10
>> 1
# Вывод:
>> 10
>> 8
>> 6
>> 4
>> 2
```
2. От A до B на три
Пользователь вводит числа A и B (A < B, A меньше B). Выведите числа от A до B включительно, которые делятся на три.
```python
# Ввод:
>> 1
>> 15
# Вывод:
>> 3
>> 6
>> 9
>> 12
>> 15
```
3. Сумма чисел
Пользователь вводит числа до тех пор, пока не введет 0. Выведите сумму введенных чисел (0 считать не нужно).
```python
# Ввод:
>> 1
>> 15
>> 10
>> 11
>> 2
>> 0
# Вывод:
>> Сумма равна: 39
```
4. Максимум
Пользователь вводит числа до тех пор, пока не введет 0. Выведите максимальное введенное число (0 считать не нужно).
```python
# Ввод:
>> 1
>> 15
>> 10
>> 11
>> 2
>> 0
# Вывод:
>> Максимум равен: 15
```
5. Минимум
Пользователь вводит числа до тех пор, пока не введет 0. Выведите минимальное введенное число (0 считать не нужно).
```python
# Ввод:
>> 1
>> 15
>> 10
>> 11
>> 2
>> 0 # 0 не входит в последовательность
# Вывод:
>> Минимум равен: 1
```

6. Факториал
Пользователь вводит число N. Выведите факториал число N. Факториал числа N - это произведение всех чисел от 1 до N включительно. Например, факториал числа 5 равен 120.
```python
# Ввод:
>> 5
# Вывод:
>> 120
```
```python
# Ввод:
>> 3
# Вывод:
>> 6
```
```python
# Ввод:
>> 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 ...
```python
# Ввод:
>> 5
# Вывод:
>> 5
```
```python
# Ввод:
>> 10
# Вывод:
>> 55
```
```python
# Ввод:
>> 8
# Вывод:
>> 21
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-python)

</TableOfContents>

## 6. Списки в Python

Список - это непрерывная динамическая коллекция элементов. Каждому элементу списка присваивается порядковый номер - его индекс. Первый индекс равен нулю, второй - единице и так далее. Основные операции для работы со списками - это индексирование, срезы, добавление и удаление элементов, а также проверка на наличие элемента в последовательности.

Создание пустого списка выглядит так:
```python
empty_list = []
```
Создадим список, состоящий из нескольких чисел:
```python
numbers = [40, 20, 90, 11, 5]
```
Настало время строковых переменных:
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
```
Не будем забывать и о дробях:
```python
fractions = [3.14, 2.72, 1.41, 1.73, 17.9]
```
Мы можем создать список, состоящий из различных типов данных:
```python
values = [3.14, 10, 'Hello world!', False, 'Python is the best']
```
И такое возможно (⊙_⊙)
```python
list_of_lists = [[2, 4, 0], [11, 2, 10], [0, 19, 27]]
```
Индексирование
Что же такое индексирование? Это загадочное слово обозначает операцию обращения к элементу по его порядковому номеру ( ( ･ω･)ア напоминаю, что нумерация начинается с нуля). Проиллюстрируем это на примере:
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
print(fruits[0])
print(fruits[1])
print(fruits[4])
```
```python
>>> Apple
>>> Grape
>>> Orange
```
Списки в Python являются изме­няемым типом данных. Мы можем изменять содер­жимое каждой из ячеек:
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
fruits[0] = 'Watermelon'
fruits[3] = 'Lemon'
print(fruits)
```
```python
>>> ['Watermelon', 'Grape', 'Peach', 'Lemon', 'Orange']
```
Индексирование работает и в обратную сторону. Как такое возможно? Всё просто, мы обра­щаемся к элементу списка по отрица­тельному индексу. Индекс с номе­ром -1 дает нам доступ к после­днему элементу, -2 к предпоследнему и так далее.
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
print(fruits[-1])
print(fruits[-2])
print(fruits[-3])
print(fruits[-4])
```
```python
>>> Orange
>>> Banan
>>> Peach
>>> Grape
```
Создание списка с помощью list()
Переходим к способам создания списка. Самый простой из них был приведен выше. Еще раз для закрепления:
```python
smiles = ['(ಠ_ಠ)', '(￣﹃￣)', '( ͡° ͜ʖ ͡°)', '(╮°-°)╮']
```
А есть еще способы? Да, есть. Один из них — создание списка с помощью функции list() В неё мы можем передать любой итерируемый объект (да-да, тот самый по которому можно запустить цикл (• ᵕ •) )

Рассмотрим несколько примеров:
```python
letters = list('abcdef')
numbers = list(range(10))
even_numbers = list(range(0, 10, 2))
print(letters)
print(numbers)
print(even_numbers)
```

```python
>>> ['a', 'b', 'c', 'd', 'e', 'f']
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [0, 2, 4, 6, 8]
```
Длина списка
С созданием списка вроде ра­зобрались. Следующий вопрос: как узнать длину списка? Можно, конечно, просто посчитать количество элементов... (⊙_⊙) Но есть способ получше! Функция len() возвращает длину любой итерируемой переменной, переменной, по которой можно запустить цикл. Рассмотрим пример:

```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
print(len(fruits))
```

```python
>>> 5
```
```python
numbers = [40, 20, 90]
print(len(numbers))
```
```python
>>> 3
```
"...любой итерируемой", а это значит:
```python
string = 'Hello world'
print(len(string))
# 11
```
```python
>>> 11
```

```python
print(len(range(10)))
```
```python
>>> 10
```
Срезы
В начале статьи что-то гово­рилось о "срезах". Давайте разберем подробнее, что это такое. Срезом называется неко­торая подпос­ледователь­ность. Принцип действия срезов очень прост: мы "отре­заем" кусок от исходной последова­тель­ности элемента, не меняя её при этом. Я сказал "последо­вательность", а не "спи­сок", потому что срезы работают и с другими итерируемыми типами данных, например, со строками.
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
part_of_fruits = fruits[0:3]
print(part_of_fruits)
```
```python
>>> ['Apple', 'Grape', 'Peach']
```
Детально рассмотрим синтаксис срезов:

итерируемая_переменная[начальный_индекс:конечный_индекс - 1:длина_шага]

Обращаю ваше внимание, что мы делаем срез от начального индекса до конечного индекса - 1. То есть i = начальный_индекс и i < конечный индекс

Больше примеров!
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
print(fruits[0:1])
# Если начальный индекс равен 0, то его можно опустить
print(fruits[:2])
print(fruits[:3])
print(fruits[:4])
print(fruits[:5])
# Если конечный индекс равен длине списка, то его тоже можно опустить
print(fruits[:len(fruits)])
print(fruits[::])
```
```python
>>> ['Apple']
>>> ['Apple', 'Grape']
>>> ['Apple', 'Grape', 'Peach']
>>> ['Apple', 'Grape', 'Peach', 'Banan']
>>> ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
>>> ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
>>> ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
```
Самое время понять, что делает третий параметр среза - длина шага!
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
print(fruits[::2])
print(fruits[::3])
# Длина шага тоже может быть отрицательной!
print(fruits[::-1])
print(fruits[4:2:-1])
print(fruits[3:1:-1])
```
```python
>>> ['Apple', 'Peach', 'Orange']
>>> ['Apple', 'Banan']
>>> ['Orange', 'Banan', 'Peach', 'Grape', 'Apple']
>>> ['Orange', 'Banan']
>>> ['Banan', 'Peach']
```
А теперь вспоминаем всё, что мы знаем о циклах. В Python их целых два! Цикл for и цикл while Нас интересует цикл for, с его помощью мы можем перебирать зна­чения и индексы наших последовательностей. Начнем с перебора значений:
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
for fruit in fruits:
    print(fruit, end=' ')
```
```python
>>> Apple Grape Peach Banan Orange
```
Выглядит несложно, правда? В переменную fruit объявлен­ную в цикле по очереди записываются значения всех элементов списка fruits

А что там с перебором индексов?
```python
for index in range(len(fruits)):
    print(fruits[index], end=' ')
```
Этот пример гораздо интереснее предыдущего! Что же здесь происходит? Для начала разбе­ремся, что делает функция range(len(fruits))

Мы с вами знаем, что функция len() возвращает длину списка, а range() генерирует диапазон целых чисел от 0 до len()-1.

Сложив 2+2, мы получим, что переменная index принимает значения в диапазоне от 0 до len()-1. Идем дальше, fruits[index] - это обращение по индексу к элементу с индексом index списка fruits. А так как переменная index принимает значения всех индексов списка fruits, то в цикле мы переберем значения всех элементов нашего списка!

Операция in
С помощью in мы можем проверить наличие элемента в списке, строке и любой другой итерируемой переменной.
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
if 'Apple' in fruits:
    print('В списке есть элемент Apple')
```
```python
>>> В списке есть элемент Apple
```
```python
fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
if 'Lemon' in fruits:
    print('В списке есть элемент Lemon')
else:'
    print('В списке НЕТ элемента Lemon')
```
```python
>>> В списке НЕТ элемента Lemon
```
Приведу более сложный пример:
```python
all_fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']
my_favorite_fruits = ['Apple', 'Banan', 'Orange']
for item in all_fruits:
    if item in my_favorite_fruits:
        print(item + ' is my favorite fruit')
    else:
        print('I do not like ' + item)

>>> Apple is my favorite fruit
>>> I do not like Grape
>>> I do not like Peach
>>> Banan is my favorite fruit
>>> Orange is my favorite fruit
```
Методы для работы со списками
Начнем с метода append(), который добавляет элемент в конец списка:
```python
# Создаем список, состоящий из четных чисел от 0 до 8 включительно
numbers = list(range(0,10,2))
# Добавляем число 200 в конец списка
numbers.append(200)
numbers.append(1)
numbers.append(2)
numbers.append(3)
print(numbers)
```
```python
>>> [0, 2, 4, 6, 8, 200, 1, 2, 3]
```
Мы можем передавать методу append() абсолютно любые значения:
```python
all_types = [10, 3.14, 'Python', ['I', 'am', 'list']]
all_types.append(1024)
all_types.append('Hello world!')
all_types.append([1, 2, 3])
print(all_types)
```
```python
>>> [10, 3.14, 'Python', ['I', 'am', 'list'], 1024, 'Hello world!', [1, 2, 3]]
```
Метод append() отлично выпол­няет свою функцию. Но, что делать, если нам нужно добавить элемент в сере­дину списка? Это умеет метод insert(). Он добавляет элемент в список на произ­вольную позицию. insert() принимает в качестве первого аргу­мента позицию, на которую нужно вставить элемент, а вторым — сам элемент.
```python
# Создадим список чисел от 0 до 9
numbers = list(range(10))
# Добавление элемента 999 на позицию с индексом 0
numbers.insert(0, 999)
print(numbers) # первый print
numbers.insert(2, 1024)
print(numbers) # второй print
numbers.insert(5, 'Засланная строка-шпион')
print(numbers) # третий print
```
```python
>>> [999, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # первый print
>>> [999, 0, 1024, 1, 2, 3, 4, 5, 6, 7, 8, 9] # второй print
>>> [999, 0, 1024, 1, 2, 'Засланная строка-шпион', 3, 4, 5, 6, 7, 8, 9] # третий print
```
Отлично! Добавлять элементы в список мы научи­лись, осталось понять, как их из него удалять. Метод pop() удаляет эле­мент из списка по его индексу:
```python
numbers = list(range(10))
print(numbers) # 1
# Удаляем первый элемент
numbers.pop(0)
print(numbers) # 2
numbers.pop(0)
print(numbers) # 3
numbers.pop(2)
print(numbers) # 4
# Чтобы удалить последний элемент, вызовем метод pop без аргументов
numbers.pop()
print(numbers) # 5
numbers.pop()
print(numbers) # 6
```
```python
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 1
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9] # 2
>>> [2, 3, 4, 5, 6, 7, 8, 9] # 3
>>> [2, 3, 5, 6, 7, 8, 9] # 4
>>> [2, 3, 5, 6, 7, 8] # 5
>>> [2, 3, 5, 6, 7] # 6
```
Теперь мы знаем, как удалять элемент из списка по его инде­ксу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove(), кото­рый удаляет пер­вый найденный по значению элемент в списке.
```python
all_types = [10, 'Python', 10, 3.14, 'Python', ['I', 'am', 'list']]
all_types.remove(3.14)
print(all_types) # 1
all_types.remove(10)
print(all_types) # 2
all_types.remove('Python')
print(all_types) # 3
```
```python
>>> [10, 'Python', 10, 'Python', ['I', 'am', 'list']] # 1
>>> ['Python', 10, 'Python', ['I', 'am', 'list']] # 2
>>> [10, 'Python', ['I', 'am', 'list']] # 3
```
А сейчас немного посчитаем, посчитаем эле­менты списка с помощью метода count()
```python
numbers = [100, 100, 100, 200, 200, 500, 500, 500, 500, 500, 999]
print(numbers.count(100)) # 1
print(numbers.count(200)) # 2
print(numbers.count(500)) # 3
print(numbers.count(999)) # 4
```
```python
>>> 3 # 1
>>> 2 # 2
>>> 5 # 3
>>> 1 # 4
```
В программировании, как и в жизни, проще работать с упоря­доченными дан­ными, в них легче ори­енти­ро­ваться и что-либо искать. Метод sort() сорти­рует список по воз­раста­нию значений его элементов.
```python
numbers = [100, 2, 11, 9, 3, 1024, 567, 78]
numbers.sort()
print(numbers) # 1
fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']
fruits.sort()
print(fruits) # 2
```
```python
>>> [2, 3, 9, 11, 78, 100, 567, 1024] # 1
>>> ['Apple', 'Banan', 'Grape', 'Orange', 'Peach'] # 2
```
Мы можем изменять порядок сортировки с помощью пара­метра reverse. По умол­чанию этот параметр равен False
```python
fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']
fruits.sort()
print(fruits) # 1
fruits.sort(reverse=True)
print(fruits) # 2
```
```python
>>> ['Apple', 'Banan', 'Grape', 'Orange', 'Peach'] # 1
>>> ['Peach', 'Orange', 'Grape', 'Banan', 'Apple'] # 2
```
Иногда нам нужно перевернуть список, не спраши­вайте меня зачем... Для этого в самом лучшем языке прог­рам­миро­вания на этой планете JavaScr..­Python есть метод reverse():
```python
numbers = [100, 2, 11, 9, 3, 1024, 567, 78]
numbers.reverse()
print(numbers) # 1
fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']
fruits.reverse()
print(fruits) # 2
```
```python
>>> [78, 567, 1024, 3, 9, 11, 2, 100] # 1
>>> ['Apple', 'Banan', 'Peach', 'Grape', 'Orange'] # 2
```
Допустим, у нас есть два списка и нам нужно их объединить. Програм­мисты на C++ cразу же кинулись писать циклы for, но мы пишем на python, а в python у спис­ков есть полез­ный метод extend(). Этот метод вызы­вается для одного списка, а в качестве аргу­мента ему пере­дается другой список, extend() запи­сывает в конец первого из них начало вто­рого:
```python
fruits = ['Banana', 'Apple', 'Grape']
vegetables = ['Tomato', 'Cucumber', 'Potato', 'Carrot']
fruits.extend(vegetables)
print(fruits)
```
```python
>>> ['Banana', 'Apple', 'Grape', 'Tomato', 'Cucumber', 'Potato', 'Carrot']
```
В природе существует специ­аль­ный метод для очистки списка — clear()
```python
fruits = ['Banana', 'Apple', 'Grape']
vegetables = ['Tomato', 'Cucumber', 'Potato', 'Carrot']
fruits.clear()
vegetables.clear()
print(fruits)
print(vegetables)
```
```python
>>> []
>>> []
```
Осталось совсем чуть-чуть всего лишь пара мето­дов, так что делаем последний рывок! Метод index() возв­ращает индекс эле­мента. Рабо­тает это так: вы пере­даете в качестве аргу­мента в index() значение элемента, а метод возв­ращает его индекс:
```python
fruits = ['Banana', 'Apple', 'Grape']
print(fruits.index('Apple'))
print(fruits.index('Banana'))
print(fruits.index('Grape'))
```
```python
>>> 1
>>> 0
>>> 2
```
Финишная прямая! Метод copy(), только не падайте, копирует список и возвра­щает его брата-близнеца. Вообще, копи­ро­вание списков - это тема доста­точно инте­ресная, давай­те рас­смотрим её по-подробнее.

Во-первых, если мы просто прис­воим уже сущест­вующий список новой пере­менной, то на первый взгляд всё выглядит неплохо:
```python
fruits = ['Banana', 'Apple', 'Grape']
new_fruits = fruits
print(fruits)
print(new_fruits)
```
```python
>>> ['Banana', 'Apple', 'Grape']
>>> ['Banana', 'Apple', 'Grape']
```
Но есть одно маленькое "НО":
```python
fruits = ['Banana', 'Apple', 'Grape']
new_fruits = fruits
fruits.pop()
print(fruits)
print(new_fruits)
```
```python
# Внезапно, из списка new_fruits исчез последний элемент
>>> ['Banana', 'Apple']
>>> ['Banana', 'Apple']
```
При прямом присваивании спис­ков копи­рования не проис­ходит. Обе пере­менные начи­нают ссылаться на один и тот же список! То есть если мы изме­ним один из них, то изме­нится и другой. Что же тогда делать? Пользоваться методом copy(), конечно:
```python
fruits = ['Banana', 'Apple', 'Grape']
new_fruits = fruits.copy()
fruits.pop()
print(fruits)
print(new_fruits)
```

```python
>>> ['Banana', 'Apple']
>>> ['Banana', 'Apple', 'Grape']
```
Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:
```python
fruits = ['Banana', 'Apple', 'Grape', ['Orange','Peach']]
new_fruits = fruits.copy()
fruits[-1].pop()
print(fruits) # 1
print(new_fruits) # 2
```

```python
>>> ['Banana', 'Apple', 'Grape', ['Orange']] # 1
>>> ['Banana', 'Apple', 'Grape', ['Orange']] # 2
```
Решение задач
1. Создайте список из 10 четных чисел и выведите его с помощью цикла for

2. Создайте список из 5 элементов. Сделайте срез от второго индекса до четвертого

3. Создайте пустой список и добавьте в него 10 случайных чисел и выведите их. В данной задаче нужно использовать функцию randint.

```python
from random import randint
n = randint(1, 10) # Случайное число от 1 до 10
```

4.Удалите все элементы из списка, созданного в задании 3

5.Создайте список из введенной пользователем строки и удалите из него символы 'a', 'e', 'o'

6.Даны два списка, удалите все элементы первого списка из второго

```python
a = [1, 3, 4, 5]
b = [4, 5, 6, 7]
# Вывод
>>> [6, 7]
```

7.Создайте список из случайных чисел и найдите наибольший элемент в нем.

8.Найдите наименьший элемент в списке из задания 7

9.Найдите сумму элементов списка из задания 7

10.Найдите среднее арифметическое элементов списка из задания 7

Сложные задачи
1.Создайте список из случайных чисел. Найдите номер его последнего локального максимума (локальный максимум — это элемент, который больше любого из своих соседей).

2.Создайте список из случайных чисел. Найдите максимальное количество его одинаковых элементов.

3.Создайте список из случайных чисел. Найдите второй максимум.

```python
a = [1, 2, 3] # Первый максимум == 3, второй == 2
```
4.Создайте список из случайных чисел. Найдите количество различных элементов в нем.

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-python)

</TableOfContents>

## 7. Методы работы со списками в Python

Список - это изме­няемый и последовательный тип данных. Это значит, что мы можем добавлять, удалять и изменять любые элементы списка.

Начнем с метода append(), который добавляет элемент в конец списка:

```python
# Создаем список, состоящий из четных чисел от 0 до 8 включительно
numbers = list(range(0,10,2))
# Добавляем число 200 в конец списка
numbers.append(200)
print(numbers)
# [0, 2, 4, 6, 8, 200]
numbers.append(1)
numbers.append(2)
numbers.append(3)
print(numbers)
# [0, 2, 4, 6, 8, 200, 1, 2, 3]
```

Мы можем передавать методу append() абсолютно любые значения:

```python
all_types = [10, 3.14, 'Python', ['I', 'am', 'list']]
all_types.append(1024)
all_types.append('Hello world!')
all_types.append([1, 2, 3])
print(all_types)
# [10, 3.14, 'Python', ['I', 'am', 'list'], 1024, 'Hello world!', [1, 2, 3]]
```
Метод append() отлично выпол­няет свою функцию. Но, что делать, если нам нужно добавить элемент в сере­дину списка? Это умеет метод insert(). Он добавляет элемент в список на произ­вольную позицию. insert() принимает в качестве первого аргу­мента позицию, на которую нужно вставить элемент, а вторым — сам элемент.
```python
# Создадим список чисел от 0 до 9
numbers = list(range(10))
# Добавление элемента 999 на позицию с индексом 0
numbers.insert(0, 999)
print(numbers)
# [999, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers.insert(2, 1024)
print(numbers)
# [999, 0, 1024, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers.insert(5, 'Засланная строка-шпион')
print(numbers)
# [999, 0, 1024, 1, 2, 'Засланная строка-шпион', 3, 4, 5, 6, 7, 8, 9]
```

Отлично! Добавлять элементы в список мы научи­лись, осталось понять, как их из него удалять. Метод pop() удаляет эле­мент из списка по его индексу:

```python
numbers = list(range(10))
print(numbers)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Удаляем первый элемент
numbers.pop(0)
print(numbers)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers.pop(0)
print(numbers)
# [2, 3, 4, 5, 6, 7, 8, 9]
numbers.pop(2)
print(numbers)
# [2, 3, 5, 6, 7, 8, 9]
# Чтобы удалить последний элемент, вызовем метод pop без аргументов
numbers.pop()
print(numbers)
# [2, 3, 5, 6, 7, 8]
numbers.pop()
print(numbers)
# [2, 3, 5, 6, 7]
```
Теперь мы знаем, как удалять элемент из списка по его инде­ксу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove(), кото­рый удаляет пер­вый найденный по значению элемент в списке.

```python
all_types = [10, 'Python', 10, 3.14, 'Python', ['I', 'am', 'list']]
all_types.remove(3.14)
print(all_types)
# [10, 'Python', 10, 'Python', ['I', 'am', 'list']]
all_types.remove(10)
print(all_types)
# ['Python', 10, 'Python', ['I', 'am', 'list']]
all_types.remove('Python')
print(all_types) # [10, 'Python', ['I', 'am', 'list']]
```
А сейчас немного посчитаем, посчитаем эле­менты списка с помощью метода count()

```python
numbers = [100, 100, 100, 200, 200, 500, 500, 500, 500, 500, 999]
print(numbers.count(100))
# 3
print(numbers.count(200))
# 2
print(numbers.count(500))
# 5
print(numbers.count(999))
# 1
```

В программировании, как и в жизни, проще работать с упоря­доченными дан­ными, в них легче ори­енти­ро­ваться и что-либо искать. Метод sort() сорти­рует список по воз­раста­нию значений его элементов.

```python
numbers = [100, 2, 11, 9, 3, 1024, 567, 78]
numbers.sort()
print(numbers)
# [2, 3, 9, 11, 78, 100, 567, 1024]
fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']
fruits.sort()
print(fruits)
# ['Apple', 'Banan', 'Grape', 'Orange', 'Peach']
```

Мы можем изменять порядок сортировки с помощью пара­метра reverse. По умол­чанию этот параметр равен False

```python
fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']
fruits.sort()
print(fruits)
# ['Apple', 'Banan', 'Grape', 'Orange', 'Peach']
fruits.sort(reverse=True)
print(fruits)
# ['Peach', 'Orange', 'Grape', 'Banan', 'Apple']
```

Иногда нам нужно перевернуть список, не спраши­вайте меня зачем... Для этого в самом лучшем языке прог­рам­миро­вания на этой планете JavaScr..­Python есть метод reverse():

```python
numbers = [100, 2, 11, 9, 3, 1024, 567, 78]
numbers.reverse()
print(numbers)
# [78, 567, 1024, 3, 9, 11, 2, 100]
fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']
fruits.reverse()
print(fruits)
# ['Apple', 'Banan', 'Peach', 'Grape', 'Orange']
```
Допустим, у нас есть два списка и нам нужно их объединить. Програм­мисты на C++ cразу же кинулись писать циклы for, но мы пишем на python, а в python у спис­ков есть полез­ный метод extend(). Этот метод вызы­вается для одного списка, а в качестве аргу­мента ему пере­дается другой список, extend() запи­сывает в конец первого из них начало вто­рого:
```python
fruits = ['Banana', 'Apple', 'Grape']
vegetables = ['Tomato', 'Cucumber', 'Potato', 'Carrot']
fruits.extend(vegetables)
print(fruits)
# ['Banana', 'Apple', 'Grape', 'Tomato', 'Cucumber', 'Potato', 'Carrot']
```

В природе существует специ­аль­ный метод для очистки списка — clear()

```python
fruits = ['Banana', 'Apple', 'Grape']
vegetables = ['Tomato', 'Cucumber', 'Potato', 'Carrot']
fruits.clear()
vegetables.clear()
print(fruits)
# []
print(vegetables)
# []
```

Осталось совсем чуть-чуть всего лишь пара мето­дов, так что делаем последний рывок! Метод index() возв­ращает индекс эле­мента. Рабо­тает это так: вы пере­даете в качестве аргу­мента в index() значение элемента, а метод возв­ращает его индекс:
```python
fruits = ['Banana', 'Apple', 'Grape']
print(fruits.index('Apple'))
# 1
print(fruits.index('Banana'))
# 0
print(fruits.index('Grape'))
# 2
```

Финишная прямая! Метод copy(), только не падайте, копирует список и возвра­щает его брата-близнеца. Вообще, копи­ро­вание списков - это тема доста­точно инте­ресная, давай­те рас­смотрим её по-подробнее.

Во-первых, если мы просто прис­воим уже сущест­вующий список новой пере­менной, то на первый взгляд всё выглядит неплохо:

```python
fruits = ['Banana', 'Apple', 'Grape']
new_fruits = fruits
print(fruits)
# ['Banana', 'Apple', 'Grape']
print(new_fruits)
# ['Banana', 'Apple', 'Grape']
Но есть одно маленькое "НО":

fruits = ['Banana', 'Apple', 'Grape']
new_fruits = fruits
fruits.pop()
print(fruits)
# ['Banana', 'Apple']
print(new_fruits)
# Внезапно, из списка new_fruits исчез последний элемент
# ['Banana', 'Apple']
```

При прямом присваивании спис­ков копи­рования не проис­ходит. Обе пере­менные начи­нают ссылаться на один и тот же список! То есть если мы изме­ним один из них, то изме­нится и другой. Что же тогда делать? Пользоваться методом copy(), конечно:

```python
fruits = ['Banana', 'Apple', 'Grape']
new_fruits = fruits.copy()
fruits.pop()
print(fruits)
# ['Banana', 'Apple']
print(new_fruits)
# ['Banana', 'Apple', 'Grape']
```

Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:

```python
fruits = ['Banana', 'Apple', 'Grape', ['Orange','Peach']]
new_fruits = fruits.copy()
fruits[-1].pop()
print(fruits)
# ['Banana', 'Apple', 'Grape', ['Orange']]
print(new_fruits)
# ['Banana', 'Apple', 'Grape', ['Orange']]
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-python)

</TableOfContents>

## 8. Функции в Python

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

Функция позволяет использо­вать в про­грамме один и тот же фрагмент кода нес­колько раз.

Oбъявление функции в Python выглядит так:

```python
def function_name(argument1, argument2, ...):
    # код функции
# def - DEclare Function - "объявить функцию"
# function_name - имя функции
# (argument1, argument2, ...) - список аргументов, поступающих на вход функции при ее вызове
# тело функции - это весь код, который идет после двоеточия
```
```python
# Объявление функции

def hello(name):
    print('Hello, ' + name)

# Вызовы функции

hello('Max')
hello('Ivan')
hello('Alex')
hello('Kate')
```
```python
# Вывод

>> Hello, Max
>> Hello, Ivan
>> Hello, Alex
>> Hello, Kate
```

Оператор return возвращает значение из функции.

Представьте себе обычный калькулятор. Вы вводите первое число, операцию и второе число. Калькулятор возвращает нам результат операции над этими числами. Всё просто, не так ли? Функции точно так же умеют возвращать значение с помощью специального оператора return.

```python
# Объявление функции

def sum2(a, b):
    return a + b

# Вызовы функции

s1 = sum2(10, 2)
s2 = sum2(108, 100)
s3 = sum2(3, 1)

print(f's1 = {s1}')
print(f's2 = {s2}')
print(f's3 = {s3}')
```
```python
>> s1 = 12
>> s2 = 208
>> s3 = 4
```
```python
# Функция умножения двух чисел

def mult2(a, b):
    return a * b

# Вызовем нашу функцию

m1 = mult2(10, 2)
m2 = mult2(108, 100)
m3 = mult2(3, 1)

print(f'm1 = {m1}')
print(f'm2 = {m2}')
print(f'm3 = {m3}')
```
```python
>> m1 = 20
>> m2 = 10800
>> m3 = 3
```
Для параметров функции можно указывать значения по умолчанию. Это дает возможность вызывать функцию с меньшим числом параметров.
```python
# Аргумент name по умолчанию равен 'world'

def hello(name='world'):
    print('Hello, ' + name)

hello()
hello('Ivan')
```
```python
>> Hello, world
>> Hello, Ivan
```

Примеры
1. Квадрат
# Написать функцию square(), вычисляющую квадрат числа.

def square(number):
    return number * number # Возвращаем результат работы функции обратно в программу

a = square(2)
print(a)

>> 4

2. Периметр
# Напишите функцию perimetr, вычисляющую периметр прямоугольника со сторонами a и b.
```python
def perimetr(a, b):
    return 2 * (a + b)

p = perimetr(4, 3)
print(p)
```
```python
>> 14
```

3. Четное число
# Напишите функцию isEven, возвращающую True, если число четное, и False, если - нечетное.
```python
def isEven(x):
    return x % 2 == 0

print(isEven(10))
print(isEven(11))
```
```python
>> True
>> False
```
4. Сумма списка

```python
# Напишите функцию amountList, которая возвращает сумму всех элементов списка.

def amountList(lst):
    amount = 0
    for x in lst:
        amount += x
    return amount

print(amountList([1, 2, 3]))

mylist = [1, 2, 4, 8, 16]
s = amountList(mylist)

print(f'Сумма списка {mylist} равна {s}')
```
```python
>> 6
>> Сумма списка [1, 2, 4, 8, 16] равна 31
```

5. Фибоначчи
```python
# Напишите функцию fib, которая возвращает n-ное число Фибоначчи.
# Последовательность Фибоначчи выглядит так: 1 1 2 3 5 8 13 21 34

def fib(n):
    a, b = 0, 1
    if n == 0: return 0
    for i in range(1, n):
        a, b = b, a + b
    return b

print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(10))
```
```python
>> 1
>> 2
>> 3
>> 5
>> 55
```
6. Факториал
```python
# Напишите функцию fact, вычисляющую значение факториала числа N.
# Факториал числа - это произведение всех чисел от 1 до N.
# Например, факториал числа 5 равен 120 (5! = 120).

def fact(n):
    result = 1
    while n > 1:
        result *= n
        n -= 1
    return result

print(fact(2))
print(fact(3))
print(fact(4))
print(fact(5))
```
```python
>> 2
>> 6
>> 24
>> 120
```
Решение задач
1. Площадь круга
Напишите функцию, которая получает в качестве аргумента радиус круга и находит его площадь.
```python
# Не забудьте написать функцию circle...

print(circle(4))
print(circle(1))
```
```python
# Вывод:
>> 50.24
>> 3.14
```

2. На три
Напишите функцию, которая возвращает True, если число делится на 3, и False, если - нет.
```python
# Не забудьте написать функцию three...

print(three(4))
print(three(3))
```
```python
# Вывод:
>> False
>> True
```
3. Максимум в списке
Напишите функцию, которая возвращает максимальный элемент из переданного в нее списка.
```python
# Напишите функцию maxList...
mylist = [1, 3, 2]
print(maxList(mylist))
```
```python
# Вывод:
>> 3
```
4. Сколько четных
Напишите функцию, которая возвращает количество четных элементов в списке.
```python
# Напишите функцию evenCounter...
mylist = [1, 10, 2, 4, 6]
evens = evenCounter(mylist)
print(even)
```
```python
# Вывод:
>> 4
```
5. Уникальные
Напишите функцию, которая возвращает список с уникальными (неповторяющихся) элементам.
```python
# Напишите функцию unique...
mylist = [1, 1, 2, 1, 3, 2, 3]
print(unique(mylist))
```
```python
# Вывод:
>> [1, 2, 3]
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-python)

</TableOfContents>

## 9. Словари в Python

Словарь — неупорядоченная структура данных, которая позволяет хранить пары «ключ — значение».

```python
# Создание словаря c помощью литерала

student = {'name': 'Ivan', 'age': 12}
credentials = {'email': 'hacker1337@mail.ru', 'password': '123456'}
```
```python
# Создание словаря c помощью функции dict()

student = dict(name='Ivan', age=12)
credentials = dict(email='hacker1337@mail.ru', password='123456')
```
Для получения значения конкретного ключа используются квадратные скобки [].

```python
# Получаем значение с ключом 'name'

student = dict(name='Ivan', age=12)
print(student['name']) # -> Ivan
```

Обновление существующих значений происходит абсолютно также.
```python
# Получаем значение с ключом 'name'

student = dict(name='Ivan', age=12)
student['name'] = 'Vasya'

print(student['name']) # -> Vasya
```
Для удаления ключа и соответствующего значения из словаря можно использовать del

```python
# Удаление ключа 'age'

student = dict(name='Ivan', age=12)
del student['age']

print(student) # -> {'name': 'Ivan'}
```

Метод get() возвращает значение по указанному ключу. Если указанного ключа не существует, метод вернёт None. Также можно указать значение по умолчанию, которое будет возвращено вместо None, если ключа в словаре не окажется.
```python
# Использование метода get()

student = dict(name='Ivan', age=12)

print(student.get('name'))     # -> Ivan
print(student.get('lastname')) # -> None
print(student.get('lastname', 'No key')) # -> No key
```

Метод pop() удаляет ключ и возвращает соответствующее ему значение.

```python
# Использование метода pop()

sneakers = dict(brand='Adidas', price='9990 RUB', model='Nite Jogger')

model = sneakers.pop('model')

print(sneakers) # -> {'brand': 'Adidas', 'price': '9990 RUB'}
print(model)    # -> Nite Jogger
```
Метод keys() возвращает специальную коллекцию ключей в словаре.
```python
# Использование метода keys()

sneakers = dict(brand='Adidas', price='9990 RUB', model='Nite Jogger')

print(sneakers.keys()) # -> dict_keys(['brand', 'price', 'model'])

# dict_keys - это неизменяемая коллекция элементов.

keys = list(sneakers.keys())
print(keys) # -> ['brand', 'price', 'model']
```

Метод values() возвращает специальную коллекцию значений в словаре.
```python
# Использование метода values()

sneakers = dict(brand='Adidas', price='9990 RUB', model='Nite Jogger')

print(sneakers.values()) # -> dict_values(['Adidas', '9990 RUB', 'Nite Jogger'])

# dict_values - это неизменяемая коллекция элементов.

values = list(sneakers.values())
print(values) # -> ['Adidas', '9990 RUB', 'Nite Jogger']
```

Метод items() возвращает пары «ключ — значение» в формате кортежей.
```python
# Использование метода items()

sneakers = dict(brand='Adidas', price='9990 RUB', model='Nite Jogger')

print(sneakers.items()) # -> dict_items([('brand', 'Adidas'), ('price', '9990 RUB'), ('model', 'Nite Jogger')])

# dict_items - это неизменяемая коллекция элементов.

items = list(sneakers.items())
print(items) # -> [('brand', 'Adidas'), ('price', '9990 RUB'), ('model', 'Nite Jogger')]

sneakers = dict(brand='Adidas', price='9990 RUB', model='Nite Jogger')

# Вывод ключей словаря с помощью цикла for

for key in sneakers:
    print(key)

# -> brand
# -> price
# -> model

# Вывод значений словаря с помощью цикла for

for value in sneakers.values():
    print(value)

# -> Adidas
# -> 9990 RUB
# -> Nite Jogger

# Вывод ключей и значений словаря с помощью цикла for

for key, value in sneakers.items():
    print(key, value)

# -> brand Adidas
# -> price 9990 RUB
# -> model Nite Jogger
```
Метод setdefault() возвращает значение ключа, но если его нет, создает ключ с указанным значением (по умолчанию None).
```python
# Метод setdefault()

student = dict(name='Ivan', age=12)
student.setdefault('lastname', 'Ivanov')

print(student) # -> {'name': 'Ivan', 'age': 12, 'lastname': 'Ivanov'}
```
Решение задач
1. Пользователь
```python
# Пользователь вводит имя, фамилия, возраст. Создайте словарь user и запишите данные пользователя в него.
firstname = input('Enter your firstname: ')
lastname = input('Enter your lastname: ')
age = input('Enter your age: ')

user = dict(firstname=firstname, lastname=lastname, age=age)
print(user)
```

2. Найти слово
```python
# Выведите самое часто встречающееся слово в введенной строке.
list_of_words = ['hello', 'hello', 'hi']
words = {}

for word in list_of_words:
    words[word] = words.get(word, 0) + 1

# Функция max может получать функцию в качестве второго аргумента
freq_word = max(words, key=words.get)

print(freq_word)
```

Задачи для самостоятельного решения
1. Фрукты
Пользователь вводит число K - количество фруктов. Затем он вводит K фруктов в формате: название фрукта и его количество. Добавьте все фрукты в словарь, где название фрукта - это ключ, а количество - значение. Например:
```python
# Ввод:
>> 3 # Количество фруктов
>> Яблоко
>> 3
>> Апельсин
>> 3
>> Мандарин
>> 10
# Вывод:
>> {'Яблоко': 3, 'Апельсин': 3, 'Мандарин': 10}
```
2. Старший и младший
Пользователь вводит число N. Затем он вводит личные данные (имя и возраст) своих N друзей. Создайте список friends и добавьте в него N словарей с ключами name и age. Найдите самого младшего из друзей и выведите его имя.
```python
# Ввод:
>> 3 # Количество друзей
>> Иван
>> 11
>> Саша
>> 12
>> Леша
>> 10
# Вывод:
>> Леша
```
3. Еще немного о друзьях
Пользователь вводит число N. Затем он вводит личные данные (имя и возраст) своих N друзей. Создайте список friends и добавьте в него N словарей с ключами name и age. Выведите средний возраст всех друзей и самое длинное имя.
```python
# Ввод:
>> 3 # Количество друзей
>> Иван
>> 12
>> Иннокентий
>> 20
>> Леша
>> 10
# Вывод:
>> 14
>> Иннокентий
```
4. Английский словарь
"Пора учить английский язык", - сказал себе Степа и решил написать программу для изучения английского языка. Программа получает на вход слово на английском языке и несколько его переводов на русском языке. Составьте словарь, в котором ключ - это английское слово, а значение - это список русских слов. В этой задаче нужно использовать строчный метод split().
```python
# Ввод:
>> 4 # Количество слов
>> apple - яблоко
>> orange - оранжевый, рыжий, апельсин
>> grape - виноград, виноградный, гроздь
>> easy - простой, легкий, нетрудный, удобный, несложный
# Вывод:
>> {'apple': ['яблоко'], 'orange': ['оранжевый', 'рыжий', 'апельсин'], 'grape': ['виноград', 'виноградный', 'гроздь'], 'easy': ['простой', 'легкий', 'нетрудный', 'удобный', 'несложный']}
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)
- [5. Цикл while в Python](#5-цикл-while-в-python)
- [6. Списки в Python](#6-списки-в-python)
- [7. Методы работы со списками в Python](#7-методы-работы-со-списками-в-python)
- [8. Функции в python](#8-функции-в-python)
- [9. Словари в python](#9-словари-в-python)

</TableOfContents>