Lists: хранение многих значений

Возвращаемся к Python.

В предыдущем уроке ты изучил loops.

Твои программы научились повторять работу с помощью:

for
while

Очень хорошо.

Теперь Python может автоматически повторять задачи.

Может считать.

Может спрашивать снова.

Может считать totals.

Может показывать menus.

Красиво.

Но теперь у нас другая проблема.

Что делать, если нужно сохранить много значений?

Например:

Список продуктов.
Список пользователей.
Список оценок.
Список городов.
Список задач.
Список паролей, которые не нужно хранить plain text.

Без lists можно написать так:

product1 = "Keyboard"
product2 = "Mouse"
product3 = "Notebook"

Это работает.

Но очень быстро становится некрасиво.

А если продуктов 100?

Ты правда будешь писать:

product100 = "Something"

Пожалуйста, нет.

Python имеет лучший способ.

Lists.

Lists позволяют хранить много значений в одной variable.

Очень полезно.

Очень распространено.

Очень Python.

Что ты изучишь

В этом уроке ты изучишь:

что такое list;
как создать list;
как получать items из list;
как работают indexes;
почему indexes начинаются с 0;
как обновлять items в list;
как добавлять items через append();
как удалять items через remove();
как использовать len();
как проходить по lists через loops;
как объединять lists с conditions;
как проверять, существует ли item;
типичные ошибки начинающих;
как строить маленькие программы на основе lists.

К концу этого урока твои программы смогут работать с collections of data.

Это очень большой шаг.

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

Они работают со многими значениями.

Много пользователей.

Много продуктов.

Много задач.

Много проблем.

Очень реалистично.

Очень программирование.

Что такое list?

List — это collection of values.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

Здесь:

products

это одна variable.

Но она хранит три значения:

Keyboard
Mouse
Notebook

List использует square brackets:

[]

Items внутри list разделяются commas:

["Keyboard", "Mouse", "Notebook"]

Это намного лучше, чем писать:

product1 = "Keyboard"
product2 = "Mouse"
product3 = "Notebook"

Lists держат связанные значения вместе.

Как маленькая коробка.

Но цифровая.

И с меньшей вероятностью найти внутри случайные кабели.

Твой первый list

Создай файл:

lists.py

Напиши:

products = ["Keyboard", "Mouse", "Notebook"]

print(products)

Запусти:

python lists.py

или:

python3 lists.py

Output:

['Keyboard', 'Mouse', 'Notebook']

Python выводит весь list.

Обрати внимание, что Python показывает square brackets и quotes.

Это нормально.

Он показывает структуру list.

List — это не просто text.

Это collection.

Маленький контейнер для values.

Очень организованно.

Подозрительно организованно.

Lists могут хранить разные types

List может хранить разные types of values.

Пример:

mixed_list = ["Anna", 25, 19.99, True]

print(mixed_list)

Output:

['Anna', 25, 19.99, True]

Это работает.

Но будь осторожен.

То, что Python что-то разрешает, не означает, что это всегда хорошая идея.

Часто lists понятнее, когда хранят похожие вещи.

Хорошо:

prices = [10.99, 25.50, 5.00]
names = ["Anna", "Marco", "Sofia"]
scores = [90, 85, 72]

Менее понятно:

random_things = ["Anna", 42, True, "Pizza", 3.14]

Python даёт свободу.

Свобода красива.

Свобода также может создать хаос в square brackets.

Используй ответственно.

Доступ к items через index

Каждый item в list имеет position.

Эта position называется index.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

print(products[0])
print(products[1])
print(products[2])

Output:

Keyboard
Mouse
Notebook

Важно:

Первый item имеет index 0.

Не 1.

Python начинает считать с нуля.

Снова.

Python и ноль всё ещё очень близкие друзья.

То есть:

products[0] -> Keyboard
products[1] -> Mouse
products[2] -> Notebook

Это очень важно.

Indexes — это способ получить конкретные items из list.

Indexes начинаются с 0

Это один из самых частых сюрпризов для начинающих.

Можно ожидать, что:

products[1]

означает первый item.

Но нет.

В Python:

products[0]

означает первый item.

Пример:

cities = ["Rome", "Milan", "Naples"]

print(cities[0])

Output:

Rome

Если хочешь второй item:

print(cities[1])

Output:

Milan

Сначала это кажется странным.

Потом становится нормальным.

Потом ты начинаешь считать с нуля в голове.

В этот момент программирование уже изменило тебя.

Не обязательно в худшую сторону.

Наверное.

Получение последнего item

Можно использовать negative indexes.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

print(products[-1])

Output:

Notebook

-1 означает:

последний item

Другие примеры:

print(products[-2])
print(products[-3])

Output:

Mouse
Keyboard

Negative indexes считают с конца.

Очень полезно.

Очень Python.

Очень “я хочу последнюю вещь, но не хочу всё считать”.

Иногда Python бывает добрым.

Обновление item в list

Lists можно изменять.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

products[1] = "Gaming Mouse"

print(products)

Output:

['Keyboard', 'Gaming Mouse', 'Notebook']

Мы изменили item с index 1.

Было:

Mouse

Стало:

Gaming Mouse

Помни:

index 1 — это второй item

Python делает именно то, что ты просишь.

Даже если ты забыл, что indexes начинаются с нуля.

Python не защищает тебя от твоей собственной уверенности.

Очень учебно.

Добавление items через append()

Можно добавить item в конец list через append().

Пример:

products = ["Keyboard", "Mouse"]

products.append("Notebook")

print(products)

Output:

['Keyboard', 'Mouse', 'Notebook']

append() добавляет один item в конец.

Это очень распространено.

Пример с user input:

products = []

product = input("Product name: ")
products.append(product)

print(products)

Если пользователь введёт:

Keyboard

Output:

['Keyboard']

Empty list начинается так:

products = []

Потом можно добавлять items позже.

Очень полезно.

Очень гибко.

Очень “строим list по дороге”.

Добавление нескольких items

Можно вызывать append() много раз.

Пример:

products = []

products.append("Keyboard")
products.append("Mouse")
products.append("Notebook")

print(products)

Output:

['Keyboard', 'Mouse', 'Notebook']

Это полезно, когда values приходят один за другим.

Например:

user input
data from a file
data from a database
data from an API

Lists повсюду.

Они как сумки для data.

Но менее хаотичные.

Если только ты сам не положишь туда хаотичные data.

Тогда это уже твоя ответственность.

Наверное.

Удаление items через remove()

Можно удалить item по value через remove().

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

products.remove("Mouse")

print(products)

Output:

['Keyboard', 'Notebook']

remove() удаляет первый matching item.

Важно:

products.remove("Mouse")

означает:

Найди "Mouse" и удали его.

Не означает:

Удали item с index Mouse.

Потому что это было бы абсурдно.

Python принимает много вещей.

Но не это.

remove() требует existing item

Если ты попробуешь удалить item, которого нет, Python даст error.

Пример:

products = ["Keyboard", "Mouse"]

products.remove("Notebook")

Error:

ValueError

Почему?

Потому что "Notebook" нет в list.

Позже мы научимся лучше обрабатывать errors.

Пока что можно сначала проверять:

products = ["Keyboard", "Mouse"]

if "Notebook" in products:
    products.remove("Notebook")
else:
    print("Notebook is not in the list.")

Это безопаснее.

Программа проверяет перед удалением.

Очень ответственно.

Очень взросло.

В отличие от некоторого кода, написанного в 2 ночи.

Проверка, существует ли item

Используй in, чтобы проверить, есть ли item в list.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

if "Mouse" in products:
    print("Mouse is available.")
else:
    print("Mouse is not available.")

Output:

Mouse is available.

Можно также проверить противоположное через not in:

if "Monitor" not in products:
    print("Monitor is missing.")

Output:

Monitor is missing.

Это очень полезно.

Ты часто будешь использовать in.

Lists и in — хорошие друзья.

Как Python и ноль.

Но менее подозрительные.

Длина list через len()

len() говорит, сколько items есть в list.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

print(len(products))

Output:

Это означает, что list имеет 3 items.

Можно использовать это в messages:

products = ["Keyboard", "Mouse", "Notebook"]

print(f"We have {len(products)} products.")

Output:

We have 3 products.

len() очень полезен.

Он работает с lists.

Он также работает со strings.

Пример:

word = "Python"

print(len(word))

Output:

Python любит считать вещи.

Очень helpful.

Энергия бухгалтера.

Проход по list через loop

Lists и loops очень хорошо работают вместе.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

for product in products:
    print(product)

Output:

Keyboard
Mouse
Notebook

Это означает:

Для каждого product в products list, выведи product.

Это один из самых важных patterns в Python.

List хранит много values.

Loop обрабатывает их один за другим.

Очень мощно.

Очень распространено.

Очень “теперь мы действительно программируем”.

Лучший output с lists

Можно объединять loops и f-strings.

Пример:

products = ["Keyboard", "Mouse", "Notebook"]

for product in products:
    print(f"Product: {product}")

Output:

Product: Keyboard
Product: Mouse
Product: Notebook

Так выглядит чище.

Можно также добавить numbering:

products = ["Keyboard", "Mouse", "Notebook"]

number = 1

for product in products:
    print(f"{number}. {product}")
    number += 1

Output:

1. Keyboard
2. Mouse
3. Notebook

Это работает.

Но Python имеет ещё лучший tool для numbering.

Мы изучим его скоро.

Не сейчас.

Один дракон за раз.

Проход по prices

Lists могут хранить numbers.

Пример:

prices = [10.99, 25.50, 5.00]

for price in prices:
    print(f"Price: {price:.2f}")

Output:

Price: 10.99
Price: 25.50
Price: 5.00

Можно посчитать total:

prices = [10.99, 25.50, 5.00]

total = 0

for price in prices:
    total += price

print(f"Total: {total:.2f}")

Output:

Total: 41.49

Это очень распространённый pattern:

list of numbers
loop through numbers
calculate total

Просто.

Полезно.

Очень реально.

Много invoices начинаются именно так.

Потом приходят taxes.

И музыка становится темнее.

Поиск самого большого number

Можно использовать loop, чтобы найти самое большое number.

Пример:

scores = [75, 90, 62, 88]

highest_score = scores[0]

for score in scores:
    if score > highest_score:
        highest_score = score

print(f"Highest score: {highest_score}")

Output:

Highest score: 90

Что происходит?

Сначала предполагаем, что первый score самый большой.
Проверяем каждый score.
Если score больше, обновляем highest_score.
Выводим финальный result.

Это классический programming pattern.

Взять starting value.

Loop.

Compare.

Update.

Очень полезно.

Очень algorithmic.

Звучит fancy.

Но это просто внимательная проверка.

Как искать самую большую картошку в мешке.

Computer science — это glamour.

Empty lists

Empty list не имеет items.

Пример:

products = []

print(products)
print(len(products))

Output:

[]
0

Empty lists полезны, когда ты хочешь добавить items позже.

Пример:

products = []

products.append("Keyboard")
products.append("Mouse")

print(products)

Output:

['Keyboard', 'Mouse']

Много программ начинаются с empty list.

Потом они её заполняют.

Это очень нормально.

Empty list не является useless.

Он просто ждёт data.

Как корзина.

Очень терпеливая корзина.

Построение list из user input

Создай файл:

product_list.py

Напиши:

products = []

product_count = int(input("How many products? "))

for number in range(1, product_count + 1):
    product = input(f"Product {number}: ")
    products.append(product)

print("Your products:")

for product in products:
    print(f"- {product}")

Пример взаимодействия:

How many products? 3
Product 1: Keyboard
Product 2: Mouse
Product 3: Notebook

Output:

Your products:
- Keyboard
- Mouse
- Notebook

Это настоящая программа, которая строит list.

Пользователь даёт values.

Python сохраняет их в list.

Потом Python проходит по list и выводит их.

Очень полезно.

Очень beginner-friendly.

Очень близко к real applications.

Lists с conditions

Можно использовать conditions во время прохода по list.

Пример:

prices = [10.99, 120.00, 5.50, 250.00]

for price in prices:
    if price >= 100:
        print(f"Expensive item: {price:.2f}")

Output:

Expensive item: 120.00
Expensive item: 250.00

Это означает:

Пройди через все prices.
Выведи только prices, которые 100 или больше.

Это filtering.

Filtering означает:

Показать только items, которые соответствуют condition.

Очень распространено.

Очень полезно.

Очень database-like.

PostgreSQL гордо смотрит из угла комнаты.

Создание нового filtered list

Можно создать новый list из selected items.

Пример:

prices = [10.99, 120.00, 5.50, 250.00]

expensive_prices = []

for price in prices:
    if price >= 100:
        expensive_prices.append(price)

print(expensive_prices)

Output:

[120.0, 250.0]

Что происходит?

Начинаем с empty list.
Проходим через все prices.
Если price expensive, добавляем его в expensive_prices.
Выводим new list.

Это ещё один очень распространённый pattern.

Loop.

Check.

Append.

Поздравляю.

Ты уже делаешь real data processing.

Small data.

Но real.

Типичная ошибка: index out of range

Это неправильно:

products = ["Keyboard", "Mouse", "Notebook"]

print(products[3])

Python даёт error:

IndexError

Почему?

Потому что list имеет 3 items.

Их indexes:

0
1
2

Index 3 не существует.

Помни:

products[0]  # first item
products[1]  # second item
products[2]  # third item

Последний index:

length - 1

Если list имеет 3 items, последний index — 2.

Python не жестокий.

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

Классический Python.

Типичная ошибка: забыть quotes

Неправильно:

products = [Keyboard, Mouse, Notebook]

Python думает, что Keyboard, Mouse и Notebook — это variable names.

Но они не defined.

Правильно:

products = ["Keyboard", "Mouse", "Notebook"]

Strings требуют quotes.

Variables — нет.

Это правило возвращается снова и снова.

Как bug, который ты думал, что уже исправил.

Но более дружелюбный.

Типичная ошибка: неправильно использовать append()

Неправильно:

products = ["Keyboard"]

products.append("Mouse", "Notebook")

Это даёт error.

Почему?

Потому что append() добавляет один item за раз.

Правильно:

products = ["Keyboard"]

products.append("Mouse")
products.append("Notebook")

Output:

['Keyboard', 'Mouse', 'Notebook']

Пока что запомни:

append() добавляет один item.

Позже ты изучишь другие способы добавлять много items.

Python имеет больше tools.

Конечно имеет.

Toolbox никогда не заканчивается.

Типичная ошибка: удаление missing items

Неправильно:

products = ["Keyboard", "Mouse"]

products.remove("Notebook")

Это вызывает:

ValueError

Потому что "Notebook" нет в list.

Безопаснее:

products = ["Keyboard", "Mouse"]

if "Notebook" in products:
    products.remove("Notebook")
else:
    print("Notebook was not found.")

Всегда будь осторожен, когда удаляешь items.

Lists не могут магически удалить то, чего там нет.

Это уже была бы философская проблема.

А Python не в настроении.

Типичная ошибка: путать index и value

Посмотри на этот list:

products = ["Keyboard", "Mouse", "Notebook"]

Indexes:

0, 1, 2

Values:

Keyboard, Mouse, Notebook

Это получает item по index:

print(products[1])

Output:

Mouse

Это удаляет по value:

products.remove("Mouse")

Важная разница:

index = position
value = actual item

Не путай их.

Index — это где вещь находится.

Value — это сама вещь.

Очень просто.

Очень легко забыть.

Очень нормально для начинающих.

Мини-программа: shopping list

Создай файл:

shopping_list.py

Напиши:

shopping_list = []

while True:
    item = input("Add item or type q to quit: ")

    if item == "q":
        break

    shopping_list.append(item)

print("Your shopping list:")

for item in shopping_list:
    print(f"- {item}")

Пример:

Add item or type q to quit: Bread
Add item or type q to quit: Milk
Add item or type q to quit: Eggs
Add item or type q to quit: q

Output:

Your shopping list:
- Bread
- Milk
- Eggs

Эта программа использует:

empty list;
while True;
input();
break;
append();
for loop.

Много concepts вместе.

Очень сильная практика.

Очень реально.

Очень полезно, если ты потом правда вспомнишь купить eggs.

Мини-программа: average score

Создай файл:

average_score.py

Напиши:

scores = []

score_count = int(input("How many scores? "))

for number in range(1, score_count + 1):
    score = float(input(f"Score {number}: "))
    scores.append(score)

total = 0

for score in scores:
    total += score

average = total / len(scores)

print(f"Average score: {average:.2f}")

Пример:

How many scores? 3
Score 1: 80
Score 2: 90
Score 3: 70

Output:

Average score: 80.00

Эта программа использует:

list creation;
user input;
numeric conversion;
append();
loop through list;
total calculation;
len();
average calculation.

Это серьёзная beginner program.

Не огромная.

Но серьёзная.

Python-суп снова становится насыщеннее.

До сих пор без USB-вкуса.

Хорошо.

Мини-программа: product prices

Создай файл:

product_prices.py

Напиши:

prices = []

product_count = int(input("How many products? "))

for number in range(1, product_count + 1):
    price = float(input(f"Price for product {number}: "))
    prices.append(price)

total = 0

for price in prices:
    total += price

print(f"Total: {total:.2f}")

if total >= 100:
    print("Big order.")
else:
    print("Small order.")

Пример:

How many products? 3
Price for product 1: 20
Price for product 2: 30
Price for product 3: 60

Output:

Total: 110.00
Big order.

Теперь мы объединяем:

lists
loops
conditions
numbers
input
formatted output

Так строятся real programs.

Concept by concept.

Line by line.

Маленький кирпич.

В итоге появляется дом.

Надеемся, не с призраками indentation errors.

Практика

Создай файл:

practice_lists.py

Напиши программу, которая:

создаёт empty list called names;
спрашивает пользователя, сколько names ввести;
сохраняет каждое name в list;
выводит все names;
выводит, сколько names было добавлено;
проверяет, есть ли "Anna" в list.

Пример решения:

names = []

name_count = int(input("How many names? "))

for number in range(1, name_count + 1):
    name = input(f"Name {number}: ")
    names.append(name)

print("Names:")

for name in names:
    print(f"- {name}")

print(f"Total names: {len(names)}")

if "Anna" in names:
    print("Anna is in the list.")
else:
    print("Anna is not in the list.")

Попробуй.

Измени names.

Попробуй добавить Anna.

Попробуй не добавлять Anna.

Программа должна реагировать по-разному.

Lists плюс conditions.

Очень полезно.

Очень реально.

Мини-задание

Создай файл:

task_manager.py

Твоя программа должна:

начать с empty list called tasks;
постоянно показывать menu;
позволить пользователю добавить task;
позволить пользователю показать все tasks;
позволить пользователю выйти.

Menu:

1. Add task
2. Show tasks
q. Quit

Пример решения:

tasks = []

while True:
    print("----- Task Manager -----")
    print("1. Add task")
    print("2. Show tasks")
    print("q. Quit")

    choice = input("Choose an option: ").lower()

    if choice == "1":
        task = input("Task: ")
        tasks.append(task)
        print("Task added.")
    elif choice == "2":
        print("Tasks:")

        if len(tasks) == 0:
            print("No tasks yet.")
        else:
            for task in tasks:
                print(f"- {task}")
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Это настоящая mini application.

Она использует:

lists;
loops;
conditions;
input;
append();
len();
break.

Маленький project.

Большой progress.

Так начинаются command-line tools.

Перед тем, как стать web apps.

Перед тем, как стать dashboards.

Перед тем, как кто-то скажет:

Can we add login?

И adventure становится длиннее.

Extra challenge: remove tasks

Улучши task_manager.py.

Добавь ещё одну menu option:

3. Remove task

Потом разреши пользователю ввести task name и удалить его.

Пример идеи:

elif choice == "3":
    task = input("Task to remove: ")

    if task in tasks:
        tasks.remove(task)
        print("Task removed.")
    else:
        print("Task not found.")

Это добавляет:

checking with in;
removing with remove();
safer list updates.

Теперь твой task manager может добавлять, показывать и удалять tasks.

Всё ещё маленький.

Но очень полезный.

Маленькая productivity app.

Попробуй не потратить три часа на её улучшение.

Или потрать.

Так тоже рождаются programmers.

Checklist для начинающих

Когда твоя list-программа не работает, проверь:

Я использовал square brackets для list?
Я разделил items commas?
Я поставил strings в quotes?
Я помню, что indexes начинаются с 0?
Я не пытаюсь получить index, которого не существует?
Я использовал append() с одним item?
Я проверил, существует ли item перед remove()?
Я правильно сделал indentation в loop body?
Я использовал len(), когда нужен был number of items?
Я не перепутал index и value?

Lists сначала простые.

Потом становятся очень мощными.

Большинство beginner list errors приходят от indexes.

Indexes начинаются с нуля.

Первый item — index 0.

Последний item часто:

list_name[-1]

Запомни это.

Твой будущий debugging time скажет тебе спасибо.

Наверное молча.

Итог

Сегодня ты изучил:

lists хранят много values в одной variable;
lists используют square brackets;
list items разделяются commas;
indexes начинаются с 0;
negative indexes считают с конца;
list items можно обновлять;
append() добавляет item в конец;
remove() удаляет item по value;
in проверяет, существует ли item;
not in проверяет, отсутствует ли item;
len() возвращает number of items;
lists очень хорошо работают с loops;
lists могут хранить strings, numbers, booleans и больше;
empty lists полезны, когда нужно добавить data позже;
loops могут build, read, filter и process lists.

Это огромный шаг.

Теперь твои программы могут хранить много values.

Они могут process collections of data.

Могут строить shopping lists.

Могут считать totals.

Могут manage tasks.

Могут работать с many inputs.

Это намного ближе к real programming.

One value is nice.

Many values are reality.

Следующий урок

В следующем уроке мы изучим dictionaries.

Dictionaries позволяют хранить data через keys и values.

Вместо того чтобы хранить только:

["Anna", 25, "Rome"]

ты сможешь писать:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Это очень важно.

Lists хороши для many values.

Dictionaries хороши для structured data.

А structured data повсюду.

Users.

Products.

Orders.

Profiles.

APIs.

Очень полезно.

Очень Python.