Занятие № 7. Применение списков для решения задач

Цель: научиться применять одномерные списки для решения задач.

Теория

Создание списка

Список - это набор упорядоченных и пронумерованных элементов. Каждый элемент списка - это значение любого встроенного или определённого программистом типа. В Python списки имеют тип list.

Самый простой способ создать список - заключить его элементы в квадратные скобки и разделить запятой:

fib = [1, 1, 2, 3, 5, 8, 13]
goods = ["хлеб", "молоко", "мука"]

В Python элементы списка не обязательно должны быть одного типа:

arr = [1, 2, True, [4, 5, 6]]

Чтобы объявить пустой список, квадратные скобки оставляют пустыми:

lst = [] # пустой список

Смешивание типов

Хорошей практикой считается не смешивать в списке значения разных типов, несмотря на то, что это не запрещено синтаксисом языка. Проще отладить код со списками, в которых хранятся значения одного типа.

Оператор индексирования списка

Элементы списка пронумерованы и к ним можно обращаться по их индексу. Нумерация элементов списка начинается с нуля.

Получить элемент списка по его индексу можно с помощью оператора [ ].

fib = [1, 1, 2, 3, 5, 8, 13]
print(fib[2])
print(fib[9-8])
print(fib[-2])

fib = [1, 1, 2, 3, 5, 8, 13]
print(fib[2])
print(fib[9-8])
print(fib[-2])

Когда индекс отрицателен, это значит, что мы отсчитываем номер элемента x справа налево.

✔

Что выведется на экран после выполнения следующей программы:

alist = [3, 67, "кот", [56, 57, "Python"], [ ], 3.14, False]
print(alist[5])

False

Python

3.14

[]

Верно. Отсчёт элементов начинается с 0. Список [56, 57, "Python"] и [ ] также считаются за один элемент.

Индекс пустого списка равен 4.

Отсчёт индексов начинается с 0. Индекс элемента False - 6.

Строка "Python" находится в списке, который сам по себе будет элементом списка alist. Весь этот вложенный список считается за один элемент списка alist.

Списки относятся к изменяемому типу данных. Мы можем заменить значение, которое находится по заданному индексу:

myList = [0, 1, 4, 6]
print(myList[2])
myList[2] = 0 # меняем элемент с индексом 2 на 0
print(myList)

myList = [0, 1, 4, 6]
print(myList[2])
myList[2] = 0 # меняем элемент с индексом 2 на 0
print(myList)

Элементами списка могут быть другие списки. Чтобы получить элемент из вложенного списка операторы индексирования записываются последовательно:

magic_sq = [
    [2, 7, 6],
    [9, 5, 1],
    [4, 3, 8]
]

print(magic_sq[1][2]) # вторая строка, третий столбец

magic_sq = [
    [2, 7, 6],
    [9, 5, 1],
    [4, 3, 8]
]

print(magic_sq[1][2]) # вторая строка, третий столбец

В списке magic_sq хранится x ? элемента. Чтобы получить из этого списка элемент первой строки и второго столбца нужно записать x magic_sq[0][1].

Количество элементов списка

С помощью функции len() можно узнать количество элементов в списке:

fib = [1, 1, 2, 3, 5, 8, 13]
print(len(fib))

fib = [1, 1, 2, 3, 5, 8, 13]
print(len(fib))

Элементами списка могут быть другие структурированные типы, длину которых также можно вычислить. Длина этих элементов не учитывается в расчёте длины списка:

alist = ["Привет", 2.0, 5]
print(len(alist))
print(len(alist[0]))

alist = ["Привет", 2.0, 5]
print(len(alist))
print(len(alist[0]))

В этом примере функция len(alist) вернёт число x ? , а вызов функции len(alist[0]) вернёт число x , так как мы находим длину элемента под индексом 0.

✔

Что выведется на экран после выполнения следующей программы:

alist = [3, 67, "кот", 3.14, [True, False]]
print(len(alist))

В коде есть синтаксическая ошибка

4

5

6

Верно. Список [True, False] считается за один элемент списка alist.

Функция len() возвращает не индекс последнего элемента, а их количество.

Список [True, False] будет считаться за один элемента списка alist.

Код записан корректно.

Оператор получения среза

Чтобы получить часть списка используется оператор среза [:]. Со списками оператор среза работает также, как и для строковых значений:

a_list = ['а', 'б', 'в', 'г', 'д', 'е']
print(a_list[1:3])
print(a_list[:4])
print(a_list[3:])
print(a_list[:])

a_list = ['а', 'б', 'в', 'г', 'д', 'е']
print(a_list[1:3])
print(a_list[:4])
print(a_list[3:])
print(a_list[:])

Запустите код примера, чтобы увидеть результат работы оператора [:]. В этом примере чтобы получить срез из первых двух элементов списка нужно записать x a_list[:3].

✔

Что выведется на экран после выполнения следующей программы:

alist = [3, 67, "кот", [56, 57, "Python"], [ ], 3.14, False]
print(alist[4:])

[ [ ], 3.14]

[ [ ], 3.14, False]

[ [56, 57, "Python"], [ ], 3.14, False]

Верно. Мы получает срез элементов начиная с индекса 4 и до последнего индекса списка alist.

В срезе не указан последний индекс после :, значит мы берём все элементы до конца списка alist.

Индекс первого элемента равен 0.

✔

Что выведется на экран после выполнения следующей программы:

L = [0.34, '6', 'Курс', 'Python', -2]
print(len(L[1:-1]))

4

5

3

2

Да, в этом срезе три элемента.

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

Сложение и умножение

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

odd_list = [1, 3, 5]
even_list = [2, 4, 6]
new_list = odd_list + even_list
print(new_list)

odd_list = [1, 3, 5]
even_list = [2, 4, 6]
new_list = odd_list + even_list
print(new_list)

Умножая список на целое число получим новый список в котором элементы исходного списка повторяются заданное количество раз:

zeroes = [0] # список из одного элемента равного 0
lst = zeroes * 5
print(lst)

zeroes = [0] # список из одного элемента равного 0
lst = zeroes * 5
print(lst)

После выполнения этого кода список lst будет содержать x элементов, равных нулю.

✔

Что выведется на экран после выполнения следующей программы:

alist = [1,3,5]
blist = [2,4,6]
print(alist + blist)

[3,7,11]

[1,2,3,4,5,6]

[1,3,5,2,4,6]

6

Да, новый список содержит элементы списка alist и следующие за ними элементы списка blist.

Сложение списков не равно сумме длин списков.

Сложение списков не меняет порядка элементов в новом списке.

Сложение списков не складывает между собой элементы этих списков.

✔

Что выведется на экран после выполнения следующей программы:

alist = [1,3,5]
print(alist * 3)

[1,3,5,1,3,5,1,3,5]

[1,1,1,3,3,3,5,5,5]

9

[3,9,15]

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

В результате умножения списка на число мы не умножаем длину списка на это число.

Умножение не приведёт к повторению каждого элемента по отдельности.

Умножение списка на число не приводит к умножению каждого элемента списка на это число.

Оператор принадлежности `in`

С помощью операторов in и not in можно определить есть ли в списке указанный элемент:

lang = ["Python", "JavaScript", "C++"]
print("Python" in lang)
print("Java" not in lang)

lang = ["Python", "JavaScript", "C++"]
print("Python" in lang)
print("Java" not in lang)

Разбиение и слияние строк

Два метода класса str тесно связаны с использованием списков.

С помощью метода split() можно разделить строку и получить список подстрок. Разделитель по умолчанию - пробел. Но в скобках можно указать произвольную строку-разделитель. Сам разделитель из строки удаляется.

verse = "Кто понял жизнь тот больше не спешит"
wds = verse.split()
print(wds)

verse = "Кто понял жизнь тот больше не спешит"
wds = verse.split()
print(wds)

После выполнения этого кода в переменной wds окажется список содержащий x ? элементов.

Метод split() принимает в качестве аргумента разделитель строки:

verse = "Кто понял жизнь тот больше не спешит"
wds = verse.split("т") # разделитель - буква т
print(wds)

verse = "Кто понял жизнь тот больше не спешит"
wds = verse.split("т") # разделитель - буква т
print(wds)

Метод класса join() работает в обратную сторону. С его помощью элементы списка можно соединить в одну строку.

Запустите следующий код, чтобы увидеть работу метода join():

wds = ["Красота", "спасёт", "мир"]
glue = ';'
s = glue.join(wds)
print(s)
print(wds)

print("***".join(wds))
print("".join(wds))

wds = ["Красота", "спасёт", "мир"]
glue = ';'
s = glue.join(wds)
print(s)
print(wds)

print("***".join(wds))
print("".join(wds))

Методы класса `list`

Класс list содержит ряд методов для изменения списка:

Таблица 1: Некоторые методы класса list

Метод	Назначение
`<список>.append(x)`	Добавление `x` в конец списка
`<список>.sort()`	Сортировка списка
`<список>.reverse()`	Расположение элементов списка в обратном порядке
`<список>.index(x)`	Получение индекса первого вхождения `x`
`<список>.insert(i, x)`	Вставка в список элемента `x` по индексу `i`
`<список>.count(x)`	Получение количества повторений `x` в списке
`<список>.remove(x)`	Удаление первого вхождения `x` в список
`<список>.pop()` `<список>.pop(i)`	Удаление из списка последнего или `i`-го элемента и возврат его значения

Рассмотрим пример применения некоторых методов:

q = [] # создаём пустой список
print(q)

# добавляем к списку два элемента
q.append("курсовая.doc")
q.append("фото.jpg")
print(q)

last = q.pop() # удаляем последний элемент списка
print("Последний элемент:", last)
print(q)

q.insert(0, "!ДИПЛОМ.docx") # вставляем элемент в начало списка
print(q)

q = [] # создаём пустой список
print(q)

# добавляем к списку два элемента
q.append("курсовая.doc")
q.append("фото.jpg")
print(q)

last = q.pop() # удаляем последний элемент списка
print("Последний элемент:", last)
print(q)

q.insert(0, "!ДИПЛОМ.docx") # вставляем элемент в начало списка
print(q)

Если мы захотим удалить из списка q первый элемент то запишем инструкцию x q.pop(0).

Операторы обработки списков собраны в следующей таблице:

Таблица 2: Инструкции и операторы для обработки списков

Инструкции и операторы	Значение
`+`	Объединение списков
`*`	Повторение
`<список>[]`	Индексирование
`<список>[:]`	Срез
`len(<список>)`	Количество элементов
`for <элемент> in <список>`	Перебор элементов списка
`<выражение> in <список>`	Проверка принадлежности (`bool`)

Тип данных Кортеж

В Python есть ещё один последовательный тип данных - кортеж (тип tuple). В отличие от списков, содержимое кортежа нельзя редактировать после создания:

data = (1, 2, 3)    # создание кортежа
print(data[0])      # обращение к элементу кортежа по индексу
data[0] = 0         # возникнет ошибка!

data = (1, 2, 3)    # создание кортежа
print(data[0])      # обращение к элементу кортежа по индексу
data[0] = 0         # возникнет ошибка!

Кортежи в Python имеют несколько применений: одновременное присваивание, возврат нескольких значений из функции, передача аргументов в функции и др.

Подробнее с кортежами можно познакомиться по ссылке.

Разминка

Запишите результат вывода для каждой строки кода.

lst = [10, 20, 30, 40, 50]

print(lst[2]) ↪︎︎ x ?

print(lst[1:4]) ↪︎︎ x [20, 30, 40]

print(len(lst[1:4])) ↪︎︎ x ?

print(30 in lst) ↪︎︎ x True

lst = [1.5, 2.5, 3.5]
lst.append(4.5)
print(lst)

↪︎︎ x [1.5, 2.5, 3.5, 4.5]

lst = [3.5, 1.5, 2.5]
lst.sort()
print(lst)

↪︎︎ x [1.5, 2.5, 3.5]

lst = ["a", "b", "c"]
print(lst.index("b"))

↪︎︎ x ?

lst = ["x", "y", "x"]
print(lst.count("x"))

↪︎︎ x ?

lst = [100, 200, 300, 400, 500]

print(lst[3]) ↪︎︎ x ?

print(lst[2:5]) ↪︎︎ x [300, 400, 500]

print(len(lst[2:5])) ↪︎︎ x ?

print(600 in lst) ↪︎︎ x False

lst = [2.1, 3.2, 4.3]
lst.append(5.4)
print(lst)

↪︎︎ x [2.1, 3.2, 4.3, 5.4]

lst = [4.3, 2.1, 3.2]
lst.sort()
print(lst)

↪︎︎ x [2.1, 3.2, 4.3]

lst = ["p", "q", "r"]
print(lst.index("r"))

↪︎︎ x ?

lst = ["m", "n", "m"]
print(lst.count("m"))

↪︎︎ x ?

lst = [5, 10, 15, 20, 25]

print(lst[0]) ↪︎︎ x ?

print(lst[1:3]) ↪︎︎ x [10, 15]

print(len(lst[1:3])) ↪︎︎ x ?

print(15 in lst) ↪︎︎ x True

lst = [1.0, 2.0, 3.0]
lst.append(4.0)
print(lst)

↪︎︎ x [1.0, 2.0, 3.0, 4.0]

lst = [3.0, 1.0, 2.0]
lst.sort()
print(lst)

↪︎︎ x [1.0, 2.0, 3.0]

lst = ["d", "e", "f"]
print(lst.index("d"))

↪︎︎ x ?

lst = ["k", "l", "k"]
print(lst.count("k"))

↪︎︎ x ?

lst = [7, 14, 21, 28, 35]

print(lst[4]) ↪︎︎ x ?

print(lst[0:3]) ↪︎︎ x [7, 14, 21]

print(len(lst[0:3])) ↪︎︎ x ?

print(42 in lst) ↪︎︎ x False

lst = [5.5, 6.5, 7.5]
lst.append(8.5)
print(lst)

↪︎︎ x [5.5, 6.5, 7.5, 8.5]

lst = [7.5, 5.5, 6.5]
lst.sort()
print(lst)

↪︎︎ x [5.5, 6.5, 7.5]

lst = ["u", "v", "w"]
print(lst.index("w"))

↪︎︎ x ?

lst = ["h", "i", "h"]
print(lst.count("h"))

↪︎︎ x ?

lst = [3, 6, 9, 12, 15]

print(lst[1]) ↪︎︎ x ?

print(lst[2:4]) ↪︎︎ x [9, 12]

print(len(lst[2:4])) ↪︎︎ x ?

print(18 in lst) ↪︎︎ x False

lst = [0.5, 1.5, 2.5]
lst.append(3.5)
print(lst)

↪︎︎ x [0.5, 1.5, 2.5, 3.5]

lst = [2.5, 0.5, 1.5]
lst.sort()
print(lst)

↪︎︎ x [0.5, 1.5, 2.5]

lst = ["s", "t", "u"]
print(lst.index("t"))

↪︎︎ x ?

lst = ["z", "y", "z"]
print(lst.count("z"))

↪︎︎ x ?

lst = [8, 16, 24, 32, 40]

print(lst[3]) ↪︎︎ x ?

print(lst[1:5]) ↪︎︎ x [16, 24, 32, 40]

print(len(lst[1:5])) ↪︎︎ x ?

print(48 in lst) ↪︎︎ x False

lst = [3.3, 4.4, 5.5]
lst.append(6.6)
print(lst)

↪︎︎ x [3.3, 4.4, 5.5, 6.6]

lst = [5.5, 3.3, 4.4]
lst.sort()
print(lst)

↪︎︎ x [3.3, 4.4, 5.5]

lst = ["g", "h", "i"]
print(lst.index("g"))

↪︎︎ x ?

lst = ["c", "d", "c"]
print(lst.count("c"))

↪︎︎ x ?

lst = [1, 3, 5, 7, 9]

print(lst[2]) ↪︎︎ x ?

print(lst[0:4]) ↪︎︎ x [1, 3, 5, 7]

print(len(lst[0:4])) ↪︎︎ x ?

print(11 in lst) ↪︎︎ x False

lst = [7.7, 8.8, 9.9]
lst.append(10.0)
print(lst)

↪︎︎ x [7.7, 8.8, 9.9, 10.0]

lst = [9.9, 7.7, 8.8]
lst.sort()
print(lst)

↪︎︎ x [7.7, 8.8, 9.9]

lst = ["j", "k", "l"]
print(lst.index("l"))

↪︎︎ x ?

lst = ["n", "o", "n"]
print(lst.count("n"))

↪︎︎ x ?

lst = [2, 4, 8, 16, 32]

print(lst[4]) ↪︎︎ x ?

print(lst[1:3]) ↪︎︎ x [4, 8]

print(len(lst[1:3])) ↪︎︎ x ?

print(64 in lst) ↪︎︎ x False

lst = [1.1, 2.2, 3.3]
lst.append(4.4)
print(lst)

↪︎︎ x [1.1, 2.2, 3.3, 4.4]

lst = [3.3, 1.1, 2.2]
lst.sort()
print(lst)

↪︎︎ x [1.1, 2.2, 3.3]

lst = ["a", "b", "c"]
print(lst.index("a"))

↪︎︎ x ?

lst = ["e", "f", "e"]
print(lst.count("e"))

↪︎︎ x ?

lst = [10, 20, 30, 40, 50, 60]

print(lst[5]) ↪︎︎ x ?

print(lst[3:6]) ↪︎︎ x [40, 50, 60]

print(len(lst[3:6])) ↪︎︎ x ?

print(70 in lst) ↪︎︎ x False

lst = [6.0, 7.0, 8.0]
lst.append(9.0)
print(lst)

↪︎︎ x [6.0, 7.0, 8.0, 9.0]

lst = [8.0, 6.0, 7.0]
lst.sort()
print(lst)

↪︎︎ x [6.0, 7.0, 8.0]

lst = ["m", "n", "o"]
print(lst.index("o"))

↪︎︎ x ?

lst = ["r", "s", "r"]
print(lst.count("r"))

↪︎︎ x ?

lst = [11, 22, 33, 44, 55]

print(lst[0]) ↪︎︎ x ?

print(lst[2:5]) ↪︎︎ x [33, 44, 55]

print(len(lst[2:5])) ↪︎︎ x ?

print(66 in lst) ↪︎︎ x False

lst = [4.5, 5.5, 6.5]
lst.append(7.5)
print(lst)

↪︎︎ x [4.5, 5.5, 6.5, 7.5]

lst = [6.5, 4.5, 5.5]
lst.sort()
print(lst)

↪︎︎ x [4.5, 5.5, 6.5]

lst = ["w", "x", "y"]
print(lst.index("x"))

↪︎︎ x ?

lst = ["b", "c", "b"]
print(lst.count("b"))

↪︎︎ x ?

lst = [15, 30, 45, 60, 75]

print(lst[3]) ↪︎︎ x ?

print(lst[1:4]) ↪︎︎ x [30, 45, 60]

print(len(lst[1:4])) ↪︎︎ x ?

print(90 in lst) ↪︎︎ x False

lst = [9.9, 8.8, 7.7]
lst.append(6.6)
print(lst)

↪︎︎ x [9.9, 8.8, 7.7, 6.6]

lst = [7.7, 9.9, 8.8]
lst.sort()
print(lst)

↪︎︎ x [7.7, 8.8, 9.9]

lst = ["f", "g", "h"]
print(lst.index("h"))

↪︎︎ x ?

lst = ["t", "u", "t"]
print(lst.count("t"))

↪︎︎ x ?

lst = [25, 50, 75, 100, 125]

print(lst[2]) ↪︎︎ x ?

print(lst[0:5]) ↪︎︎ x [25, 50, 75, 100, 125]

print(len(lst[0:5])) ↪︎︎ x ?

print(150 in lst) ↪︎︎ x False

lst = [2.0, 4.0, 6.0]
lst.append(8.0)
print(lst)

↪︎︎ x [2.0, 4.0, 6.0, 8.0]

lst = [6.0, 2.0, 4.0]
lst.sort()
print(lst)

↪︎︎ x [2.0, 4.0, 6.0]

lst = ["i", "j", "k"]
print(lst.index("i"))

↪︎︎ x ?

lst = ["v", "w", "v"]
print(lst.count("v"))

↪︎︎ x ?

lst = [4, 8, 12, 16, 20]

print(lst[1]) ↪︎︎ x ?

print(lst[2:5]) ↪︎︎ x [12, 16, 20]

print(len(lst[2:5])) ↪︎︎ x ?

print(24 in lst) ↪︎︎ x False

lst = [3.0, 6.0, 9.0]
lst.append(12.0)
print(lst)

↪︎︎ x [3.0, 6.0, 9.0, 12.0]

lst = [9.0, 3.0, 6.0]
lst.sort()
print(lst)

↪︎︎ x [3.0, 6.0, 9.0]

lst = ["l", "m", "n"]
print(lst.index("m"))

↪︎︎ x ?

lst = ["y", "z", "y"]
print(lst.count("y"))

↪︎︎ x ?

lst = [7, 14, 21, 28, 35]

print(lst[4]) ↪︎︎ x ?

print(lst[1:4]) ↪︎︎ x [14, 21, 28]

print(len(lst[1:4])) ↪︎︎ x ?

print(42 in lst) ↪︎︎ x False

lst = [8.0, 16.0, 24.0]
lst.append(32.0)
print(lst)

↪︎︎ x [8.0, 16.0, 24.0, 32.0]

lst = [24.0, 8.0, 16.0]
lst.sort()
print(lst)

↪︎︎ x [8.0, 16.0, 24.0]

lst = ["o", "p", "q"]
print(lst.index("q"))

↪︎︎ x ?

lst = ["A", "B", "A"]
print(lst.count("A"))

↪︎︎ x ?

Примеры

Познакомьтесь с готовым решением задачи. Ответьте на вопросы после кода решения задачи.

Пример “Шаблоны кода” (ex01.py)

Программа принимает на вход n вещественных чисел - длин отрезков пути, пройденных марсоходом. Значения вводятся в километрах. Пример входных значений показан на рисунке¹:

Переведите все введённых значения в метры.

Вычислите суммарный путь \(S\), пройденный марсоходом.

Найдите длину минимального отрезка пути, пройденного роботом и его индекс.

Заполнение списка

Код для ввода значений и сохранения их в списке выглядит следующим образом:

n = int(input("Количество отрезков: "))

lst = []

for i in range(n):
    el = float(input("> ")) # ввод вещественного числа
    lst.append(el)          # добавляем значение в конец списка
    
print(lst) # вывод содержимого списка на экран

Запустите программу и протестируйте её работу:

Количество отрезков: <{3}> ++enter++
> <{1.4}>  ++enter++
> <{0.44}> ++enter++
> <{0.56}> ++enter++
[1.4, 0.44, 0.56]

Цикл for выполнится x n раз. На каждой итерации цикла будем добавлять в переменную под именем x ? очередное значение, вводимое с клавиатуры.

Преобразование элементов списка

Преобразуем все значения в списке из км в м.

Предупреждение

Следующий код и дальнейшие фрагменты решения дописывайте в отрытой программе ex01.py после существующего кода.

for i in range(n):
    lst[i] = lst[i] * 1000

print(lst) # вывод элементов списка на экран

Запустите программу и протестируйте её работу:

Количество отрезков: <{3}> ++enter++
> <{1.4}>  ++enter++
> <{0.44}> ++enter++
> <{0.56}> ++enter++
[1.4, 0.44, 0.56]
[1400.0, 440.0, 560.0]

Переменная цикла под именем x ? будет принимать значения от x ? до x n-1. Это позволит переменной цикла перебрать индексы всех элементов списка lst.

Сумма элементов списка

Вычислим сумму элементов списка.

sum_acc = 0
for el in lst:
    sum_acc = sum_acc + el

print(f"S={sum_acc} м")

Запустите программу и протестируйте её работу:

Количество отрезков: <{4}> ++enter++
> <{2.4}>  ++enter++
> <{0.25}> ++enter++
> <{1.62}> ++enter++
> <{0.56}> ++enter++
[2.4, 0.25, 1.62, 0.35]
[2400.0, 250.0, 1620.0, 350.0]
S=4620.0 м

Значение суммы будет накапливаться в переменной под именем x ? . На каждом шаге цикла очередной элемент списка lst находится в переменной под именем x ? .

Поиск минимального элемента

Остаётся найти индекс и значение минимального элемента в списке.

min_el = lst[0] # первый элемент считаем минимальным
min_ind = 0
for i in range(1, n):
    if lst[i] < min_el:
        min_el = lst[i]
        min_ind = i

print(f"{min_ind}: min={min_el} м")

Запустите программу и протестируйте её работу:

Количество отрезков: <{3}> ++enter++
> <{0.5}>  ++enter++
> <{0.3}> ++enter++
> <{0.3}> ++enter++
[0.5, 0.3, 0.3]
[500.0, 300.0, 300.0]
S=1100.0 м
1: min=300.0 м

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

Решите следующие задачи самостоятельно.

Задание № 1 (sam01.py)

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

Примеры работы программы:

Количество сотрудников:3
> <{7}> ++enter++
> <{8}> ++enter++
> <{10}> ++enter++
сотрудник 0: 35.0 руб.
сотрудник 1: 40.0 руб.
сотрудник 2: 50.0 руб.
Сумма: 125.0 руб.

В основе решения - ввод элементов и преобразование.

Задание № 2 (sam02.py)

С клавиатуры вводятся среднемесячные показания температуры за год. Найдите номер месяца с наибольшей среднемесячной температурой и выведите её значение.

Примеры работы программы:

1> <{-7}> ++enter++
2> <{-7}> ++enter++
3> <{4}> ++enter++
4> <{12}> ++enter++
5> <{19}> ++enter++
6> <{21}> ++enter++
7> <{24}> ++enter++
8> <{23}> ++enter++
9> <{17}> ++enter++
10> <{10}> ++enter++
11> <{3}> ++enter++
12> <{-1}> ++enter++
Месяц 7, температура: 24 C

За основу возьмите алгоритм поиска минимального значения в списке.

Задание № 3 (sam03.py)

Напишите программу, которая принимает на вход 4 отметки и рассчитывает средний балл без учёта одной минимальной отметки.

Примеры работы программы:

> <{8}> ++enter++
> <{7}> ++enter++
> <{9}> ++enter++
> <{5}> ++enter++
Ответ: 8.0

> <{4}> ++enter++
> <{6}> ++enter++
> <{4}> ++enter++
> <{5}> ++enter++
Ответ: 5.0

Сначала нужно найти сумму баллов.

Затем - значение минимального балла.

Найденный минимальный балл не должен использоваться для вычисления среднего трёх чисел.

Задание № 4 (sam04.py)

Создайте программу, которая создаёт аббревиатуру по введённым словам. Буквы в аббревиатуре должны быть большими.

Примеры работы программы:

Введите строку: <{запоминающее устройство}> ++enter++
Аббревиатура: ЗУ

Введите строку: <{Белорусский Государственный Педагогический Университет}> ++enter++
Аббревиатура: БГПУ

Задание № 5 (sam05.py)

Правильные ответы на вопросы теста хранятся в списке answ. Пользователь вводит ответы на вопросы. Выведите на экран количество правильных ответов. Начните код решения с предоставленного шаблона.

Шаблон программы:

sam05.py

answ = ["a", "b", "d", "c"] # список правильных ответов
n = len(answ) # количество вопросов

# далее запишите код вашего решения задачи

Примеры работы программы:

Ответ 1> <{b}> ++enter++
Ответ 2> <{d}> ++enter++
Ответ 3> <{d}> ++enter++
Ответ 4> <{c}> ++enter++
Правильных ответов: 2/4

Ответ 1> <{a}> ++enter++
Ответ 2> <{b}> ++enter++
Ответ 3> <{d}> ++enter++
Ответ 4> <{c}> ++enter++
Правильных ответов: 4/4

Задание № 6 (sam06.py)

Пользователь вводит текст. Программа рассчитывает среднюю длину слов и выводит её на экран.

Примеры работы программы²:

> <{Съешь ещё этих мягких французских булок, да выпей же чаю.}> ++enter++
Количество слов: 10
Средняя длина слова: 4.8

Сноски

Источник изображения: MarsTrek ↩︎
Для тестирования программы используется строка-панграмма.↩︎

Теория

Создание списка

Оператор индексирования списка

Количество элементов списка

Оператор получения среза

Сложение и умножение

Оператор принадлежности in

Разбиение и слияние строк

Методы класса list

Разминка

Примеры

Пример “Шаблоны кода” (ex01.py)

Заполнение списка

Преобразование элементов списка

Сумма элементов списка

Поиск минимального элемента

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

Задание № 1 (sam01.py)

Задание № 2 (sam02.py)

Задание № 3 (sam03.py)

Задание № 4 (sam04.py)

Задание № 5 (sam05.py)

Задание № 6 (sam06.py)

Сноски

Оператор принадлежности `in`

Методы класса `list`