Listy: przechowywanie wielu wartości

Witaj z powrotem.

W poprzedniej lekcji nauczyłeś się pętli.

Twoje programy nauczyły się powtarzać pracę za pomocą:

for
while

Bardzo dobrze.

Teraz Python może automatycznie powtarzać zadania.

Może liczyć.

Może pytać ponownie.

Może obliczać sumy.

Może pokazywać menu.

Pięknie.

Ale teraz mamy kolejny problem.

Co jeśli musimy przechować wiele wartości?

Na przykład:

Listę produktów.
Listę użytkowników.
Listę wyników.
Listę miast.
Listę zadań.
Listę haseł, których nie powinieneś zapisywać zwykłym tekstem.

Bez list mógłbyś napisać:

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

To działa.

Ale bardzo szybko robi się brzydkie.

A jeśli masz 100 produktów?

Naprawdę chcesz pisać:

product100 = "Something"

Proszę, nie.

Python ma lepszy sposób.

Listy.

Listy pozwalają przechowywać wiele wartości w jednej zmiennej.

Bardzo użyteczne.

Bardzo częste.

Bardzo Python.

Czego się nauczysz

W tej lekcji nauczysz się:

• czym jest lista;
• jak stworzyć listę;
• jak odczytywać elementy listy;
• jak działają indeksy;
• dlaczego indeksy zaczynają się od 0;
• jak aktualizować elementy listy;
• jak dodawać elementy przez append();
• jak usuwać elementy przez remove();
• jak używać len();
• jak przechodzić przez listy pętlami;
• jak łączyć listy z warunkami;
• jak sprawdzać, czy element istnieje;
• typowych błędów początkujących;
• jak budować małe programy oparte na listach.

Pod koniec tej lekcji twoje programy będą mogły pracować z kolekcjami danych.

To bardzo duży krok.

Bo prawdziwe programy prawie nigdy nie pracują tylko z jedną wartością.

Pracują z wieloma wartościami.

Wieloma użytkownikami.

Wieloma produktami.

Wieloma zadaniami.

Wieloma problemami.

Bardzo realistycznie.

Bardzo programistycznie.

Czym jest lista?

Lista to kolekcja wartości.

Przykład:

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

Tutaj:

products

to jedna zmienna.

Ale przechowuje trzy wartości:

Keyboard
Mouse
Notebook

Lista używa nawiasów kwadratowych:

[]

Elementy w środku listy są oddzielone przecinkami:

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

To jest dużo lepsze niż pisanie:

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

Listy trzymają powiązane wartości razem.

Jak małe pudełko.

Ale cyfrowe.

I z mniejszą szansą na losowe kable w środku.

Twoja pierwsza lista

Utwórz plik:

lists.py

Napisz:

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

print(products)

Uruchom:

python lists.py

albo:

python3 lists.py

Output:

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

Python wyświetla całą listę.

Zauważ, że Python pokazuje nawiasy kwadratowe i cudzysłowy.

To normalne.

Pokazuje strukturę listy.

Lista nie jest zwykłym tekstem.

To kolekcja.

Mały pojemnik na wartości.

Bardzo uporządkowany.

Podejrzanie uporządkowany.

Listy mogą przechowywać różne typy

Lista może przechowywać różne typy wartości.

Przykład:

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

print(mixed_list)

Output:

['Anna', 25, 19.99, True]

To działa.

Ale uważaj.

To, że Python na coś pozwala, nie znaczy, że zawsze jest to dobry pomysł.

Często listy są jaśniejsze, kiedy przechowują podobne rzeczy.

Dobrze:

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

Mniej jasno:

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

Python daje wolność.

Wolność jest piękna.

Wolność może też stworzyć chaos z nawiasami kwadratowymi.

Używaj odpowiedzialnie.

Odczytywanie elementów przez indeks

Każdy element w liście ma pozycję.

Ta pozycja nazywa się indeksem.

Przykład:

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

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

Output:

Keyboard
Mouse
Notebook

Ważne:

Pierwszy element ma indeks 0.

Nie 1.

Python zaczyna liczyć od zera.

Znowu.

Python i zero nadal są bardzo bliskimi przyjaciółmi.

Czyli:

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

To jest bardzo ważne.

Indeksy pozwalają odczytywać konkretne elementy listy.

Indeksy zaczynają się od 0

To jedna z najczęstszych niespodzianek dla początkujących.

Możesz oczekiwać, że:

products[1]

oznacza pierwszy element.

Ale nie.

W Pythonie:

products[0]

oznacza pierwszy element.

Przykład:

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

print(cities[0])

Output:

Rome

Jeśli chcesz drugi element:

print(cities[1])

Output:

Milan

Na początku wydaje się to dziwne.

Potem staje się normalne.

Potem zaczynasz liczyć od zera w głowie.

Wtedy programowanie już cię zmieniło.

Niekoniecznie na gorsze.

Prawdopodobnie.

Odczytywanie ostatniego elementu

Możesz używać ujemnych indeksów.

Przykład:

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

print(products[-1])

Output:

Notebook

-1 oznacza:

ostatni element

Inne przykłady:

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

Output:

Mouse
Keyboard

Ujemne indeksy liczą od końca.

Bardzo użyteczne.

Bardzo Python.

Bardzo “chcę ostatnią rzecz bez liczenia wszystkiego”.

Python czasem potrafi być miły.

Aktualizowanie elementu listy

Listy można zmieniać.

Przykład:

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

products[1] = "Gaming Mouse"

print(products)

Output:

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

Zmieniliśmy element pod indeksem 1.

Przed:

Mouse

Po:

Gaming Mouse

Pamiętaj:

indeks 1 to drugi element

Python robi dokładnie to, o co prosisz.

Nawet jeśli zapomnisz, że indeksy zaczynają się od zera.

Python nie ochroni cię przed twoją własną pewnością siebie.

Bardzo edukacyjne.

Dodawanie elementów przez append()

Możesz dodać element na koniec listy za pomocą append().

Przykład:

products = ["Keyboard", "Mouse"]

products.append("Notebook")

print(products)

Output:

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

append() dodaje jeden element na końcu.

To bardzo częste.

Przykład z inputem użytkownika:

products = []

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

print(products)

Jeśli użytkownik wpisze:

Keyboard

Output:

['Keyboard']

Pusta lista zaczyna się tak:

products = []

Potem możesz dodawać elementy później.

Bardzo użyteczne.

Bardzo elastyczne.

Bardzo “budujemy listę po drodze”.

Dodawanie kilku elementów

Możesz wywołać append() wiele razy.

Przykład:

products = []

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

print(products)

Output:

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

To przydatne, gdy wartości przychodzą jedna po drugiej.

Na przykład:

input użytkownika
dane z pliku
dane z bazy danych
dane z API

Listy są wszędzie.

Są jak torby na dane.

Ale mniej chaotyczne.

Chyba że włożysz do nich chaotyczne dane.

Wtedy to już twoja wina.

Prawdopodobnie.

Usuwanie elementów przez remove()

Możesz usunąć element po wartości przez remove().

Przykład:

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

products.remove("Mouse")

print(products)

Output:

['Keyboard', 'Notebook']

remove() usuwa pierwszy pasujący element.

Ważne:

products.remove("Mouse")

oznacza:

Znajdź "Mouse" i usuń go.

Nie oznacza:

Usuń element pod indeksem Mouse.

Bo to byłby absurd.

Python akceptuje wiele rzeczy.

Ale nie to.

remove() potrzebuje istniejącego elementu

Jeśli spróbujesz usunąć element, którego nie ma, Python da błąd.

Przykład:

products = ["Keyboard", "Mouse"]

products.remove("Notebook")

Błąd:

ValueError

Dlaczego?

Bo "Notebook" nie znajduje się na liście.

Później nauczymy się lepiej obsługiwać błędy.

Na razie możesz najpierw sprawdzić:

products = ["Keyboard", "Mouse"]

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

To jest bezpieczniejsze.

Program sprawdza przed usunięciem.

Bardzo odpowiedzialnie.

Bardzo dorosło.

W przeciwieństwie do części kodu pisanego o drugiej w nocy.

Sprawdzanie, czy element istnieje

Użyj in, aby sprawdzić, czy element istnieje w liście.

Przykład:

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

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

Output:

Mouse is available.

Możesz też sprawdzić odwrotnie przez not in:

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

Output:

Monitor is missing.

To jest bardzo użyteczne.

Będziesz często używać in.

Listy i in są dobrymi przyjaciółmi.

Jak Python i zero.

Ale mniej podejrzani.

Długość listy przez len()

len() mówi, ile elementów jest w liście.

Przykład:

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

print(len(products))

Output:

3

To oznacza, że lista ma 3 elementy.

Możesz używać tego w wiadomościach:

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

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

Output:

We have 3 products.

len() jest bardzo użyteczne.

Działa z listami.

Działa też ze stringami.

Przykład:

word = "Python"

print(len(word))

Output:

6

Python lubi liczyć rzeczy.

Bardzo pomocne.

Energia księgowego.

Przechodzenie przez listę pętlą

Listy i pętle świetnie ze sobą współpracują.

Przykład:

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

for product in products:
    print(product)

Output:

Keyboard
Mouse
Notebook

To oznacza:

Dla każdego product w liście products, wyświetl product.

To jeden z najważniejszych schematów w Pythonie.

Lista przechowuje wiele wartości.

Pętla przetwarza je jedna po drugiej.

Bardzo potężne.

Bardzo częste.

Bardzo “teraz programujemy naprawdę”.

Lepszy output z listami

Możesz łączyć pętle i f-stringi.

Przykład:

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

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

Output:

Product: Keyboard
Product: Mouse
Product: Notebook

Tak wygląda czyściej.

Możesz też dodać numerowanie:

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

number = 1

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

Output:

1. Keyboard
2. Mouse
3. Notebook

To działa.

Ale Python ma jeszcze ładniejsze narzędzie do numerowania.

Nauczymy się go niedługo.

Nie teraz.

Jeden smok naraz.

Przechodzenie przez ceny

Listy mogą przechowywać też liczby.

Przykład:

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

Możesz obliczyć sumę:

prices = [10.99, 25.50, 5.00]

total = 0

for price in prices:
    total += price

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

Output:

Total: 41.49

To bardzo częsty schemat:

lista liczb
pętla po liczbach
obliczenie sumy

Proste.

Użyteczne.

Bardzo realne.

Wiele faktur zaczyna się właśnie tak.

Potem wchodzą podatki.

I muzyka robi się ciemniejsza.

Znajdowanie największej liczby

Możesz użyć pętli, żeby znaleźć największą liczbę.

Przykład:

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

Co się dzieje?

Na początku zakładamy, że pierwszy wynik jest największy.
Sprawdzamy każdy score.
Jeśli score jest większy, aktualizujemy highest_score.
Wyświetlamy końcowy wynik.

To klasyczny schemat programowania.

Załóż wartość początkową.

Pętla.

Porównanie.

Aktualizacja.

Bardzo użyteczne.

Bardzo algorytmiczne.

Brzmi elegancko.

Ale to tylko uważne sprawdzanie.

Jak szukanie największego ziemniaka w worku.

Informatyka jest glamour.

Puste listy

Pusta lista nie ma elementów.

Przykład:

products = []

print(products)
print(len(products))

Output:

[]
0

Puste listy są użyteczne, gdy chcesz dodać elementy później.

Przykład:

products = []

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

print(products)

Output:

['Keyboard', 'Mouse']

Wiele programów zaczyna od pustej listy.

Potem ją wypełnia.

To bardzo normalne.

Pusta lista nie jest bezużyteczna.

Po prostu czeka na dane.

Jak koszyk.

Bardzo cierpliwy koszyk.

Budowanie listy z inputu użytkownika

Utwórz plik:

product_list.py

Napisz:

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}")

Przykładowa interakcja:

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

Output:

Your products:
- Keyboard
- Mouse
- Notebook

To prawdziwy program budujący listę.

Użytkownik podaje wartości.

Python zapisuje je w liście.

Potem Python przechodzi przez listę i je wyświetla.

Bardzo użyteczne.

Bardzo przyjazne dla początkujących.

Bardzo bliskie prawdziwym aplikacjom.

Listy z warunkami

Możesz używać warunków podczas przechodzenia przez listę.

Przykład:

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

To oznacza:

Przejdź przez wszystkie ceny.
Wyświetl tylko ceny, które są równe 100 lub większe.

To jest filtrowanie.

Filtrowanie oznacza:

Pokaż tylko elementy, które pasują do warunku.

Bardzo częste.

Bardzo użyteczne.

Bardzo podobne do bazy danych.

PostgreSQL patrzy dumnie z rogu pokoju.

Tworzenie nowej przefiltrowanej listy

Możesz stworzyć nową listę z wybranych elementów.

Przykład:

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]

Co się dzieje?

Zaczynamy od pustej listy.
Przechodzimy przez wszystkie ceny.
Jeśli cena jest expensive, dodajemy ją do expensive_prices.
Wyświetlamy nową listę.

To kolejny bardzo częsty schemat.

Pętla.

Sprawdzenie.

Append.

Gratulacje.

Teraz robisz prawdziwe przetwarzanie danych.

Małych danych.

Ale prawdziwych.

Typowy błąd: index out of range

To jest błędne:

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

print(products[3])

Python daje błąd:

IndexError

Dlaczego?

Bo lista ma 3 elementy.

Ich indeksy to:

0
1
2

Nie ma indeksu 3.

Pamiętaj:

products[0]  # pierwszy element
products[1]  # drugi element
products[2]  # trzeci element

Ostatni indeks to:

długość - 1

Jeśli lista ma 3 elementy, ostatni indeks to 2.

Python nie jest okrutny.

Po prostu znowu liczy od zera.

Klasyczny Python.

Typowy błąd: brak cudzysłowów

Źle:

products = [Keyboard, Mouse, Notebook]

Python myśli, że Keyboard, Mouse i Notebook to nazwy zmiennych.

Ale one nie są zdefiniowane.

Poprawnie:

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

Stringi potrzebują cudzysłowów.

Zmienne nie.

Ta zasada wraca znowu i znowu.

Jak bug, który myślałeś, że już naprawiłeś.

Ale bardziej przyjazny.

Typowy błąd: złe użycie append()

Źle:

products = ["Keyboard"]

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

To daje błąd.

Dlaczego?

Bo append() dodaje jeden element naraz.

Poprawnie:

products = ["Keyboard"]

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

Output:

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

Na razie zapamiętaj:

append() dodaje jeden element.

Później nauczysz się innych sposobów dodawania wielu elementów.

Python ma więcej narzędzi.

Oczywiście, że ma.

Skrzynka z narzędziami nigdy się nie kończy.

Typowy błąd: usuwanie brakujących elementów

Źle:

products = ["Keyboard", "Mouse"]

products.remove("Notebook")

To powoduje:

ValueError

Bo "Notebook" nie znajduje się w liście.

Bezpieczniej:

products = ["Keyboard", "Mouse"]

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

Zawsze uważaj przy usuwaniu elementów.

Listy nie usuwają magicznie rzeczy, których tam nie ma.

To byłby problem filozoficzny.

A Python nie jest w nastroju.

Typowy błąd: mylenie indeksu i wartości

Spójrz na tę listę:

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

Indeksy:

0, 1, 2

Wartości:

Keyboard, Mouse, Notebook

To odczytuje przez indeks:

print(products[1])

Output:

Mouse

To usuwa przez wartość:

products.remove("Mouse")

Ważna różnica:

indeks = pozycja
wartość = rzeczywisty element

Nie myl ich.

Indeks mówi, gdzie coś jest.

Wartość to sama rzecz.

Bardzo proste.

Bardzo łatwe do zapomnienia.

Bardzo normalne dla początkujących.

Mini program: lista zakupów

Utwórz plik:

shopping_list.py

Napisz:

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}")

Przykład:

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

Ten program używa:

• pustej listy;
• while True;
• input();
• break;
• append();
• pętli for.

Wiele koncepcji razem.

Bardzo mocna praktyka.

Bardzo realne.

Bardzo użyteczne, jeśli naprawdę pamiętasz, żeby kupić jajka.

Mini program: średni wynik

Utwórz plik:

average_score.py

Napisz:

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}")

Przykład:

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

Output:

Average score: 80.00

Ten program używa:

• tworzenia listy;
• inputu użytkownika;
• konwersji liczbowej;
• append();
• pętli przez listę;
• obliczania sumy;
• len();
• obliczania średniej.

To poważny program dla początkujących.

Nie ogromny.

Ale poważny.

Pythonowa zupa znowu robi się bogatsza.

Nadal bez smaku USB.

Dobrze.

Mini program: ceny produktów

Utwórz plik:

product_prices.py

Napisz:

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.")

Przykład:

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.

Teraz łączymy:

listy
pętle
warunki
liczby
input
formatowany output

Tak buduje się prawdziwe programy.

Koncepcja po koncepcji.

Linia po linii.

Mała cegła.

Mała cegła.

W końcu pojawia się dom.

Miejmy nadzieję, że nie nawiedzony przez błędy wcięć.

Praktyka

Utwórz plik:

practice_lists.py

Napisz program, który:

• tworzy pustą listę o nazwie names;
• pyta użytkownika, ile imion chce wpisać;
• zapisuje każde imię w liście;
• wyświetla wszystkie imiona;
• wyświetla, ile imion zostało dodanych;
• sprawdza, czy "Anna" jest w liście.

Przykładowe rozwiązanie:

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.")

Spróbuj.

Zmień imiona.

Spróbuj dodać Anna.

Spróbuj nie dodawać Anna.

Program powinien reagować inaczej.

Listy plus warunki.

Bardzo użyteczne.

Bardzo realne.

Mini wyzwanie

Utwórz plik:

task_manager.py

Twój program powinien:

• zacząć od pustej listy tasks;
• wielokrotnie pokazywać menu;
• pozwalać użytkownikowi dodać zadanie;
• pozwalać użytkownikowi pokazać wszystkie zadania;
• pozwalać użytkownikowi wyjść.

Menu:

1. Add task
2. Show tasks
q. Quit

Przykładowe rozwiązanie:

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.")

To prawdziwa mini aplikacja.

Używa:

• list;
• pętli;
• warunków;
• inputu;
• append();
• len();
• break.

Mały projekt.

Duży postęp.

Tak zaczynają się narzędzia terminalowe.

Zanim staną się web appkami.

Zanim staną się dashboardami.

Zanim ktoś zapyta:

Can we add login?

I przygoda robi się dłuższa.

Extra challenge: usuwanie zadań

Ulepsz task_manager.py.

Dodaj jeszcze jedną opcję menu:

3. Remove task

Potem pozwól użytkownikowi wpisać nazwę zadania i usunąć je.

Przykładowy pomysł:

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

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

To dodaje:

• sprawdzanie przez in;
• usuwanie przez remove();
• bezpieczniejsze aktualizacje listy.

Teraz twój task manager może dodawać, pokazywać i usuwać zadania.

Nadal mały.

Ale bardzo użyteczny.

Mała aplikacja produktywności.

Spróbuj nie spędzić trzech godzin na jej ulepszaniu.

Albo spędź.

Tak też powstają programiści.

Checklist dla początkujących

Kiedy twój program z listami nie działa, sprawdź:

Czy użyłem nawiasów kwadratowych dla listy?
Czy oddzieliłem elementy przecinkami?
Czy dałem stringi w cudzysłowie?
Czy pamiętam, że indeksy zaczynają się od 0?
Czy próbuję odczytać indeks, który nie istnieje?
Czy użyłem append() z jednym elementem?
Czy sprawdziłem, czy element istnieje przed remove()?
Czy poprawnie wciąłem ciało pętli?
Czy użyłem len(), kiedy potrzebowałem liczby elementów?
Czy nie pomyliłem indeksu z wartością?

Listy na początku są proste.

Potem robią się bardzo potężne.

Większość początkujących błędów z listami pochodzi od indeksów.

Indeksy zaczynają się od zera.

Pierwszy element ma indeks 0.

Ostatni element często to:

list_name[-1]

Zapamiętaj to.

Twój przyszły czas debugowania ci podziękuje.

Prawdopodobnie po cichu.

Podsumowanie

Dzisiaj nauczyłeś się:

• listy przechowują wiele wartości w jednej zmiennej;
• listy używają nawiasów kwadratowych;
• elementy listy są oddzielone przecinkami;
• indeksy zaczynają się od 0;
• ujemne indeksy liczą od końca;
• elementy listy można aktualizować;
• append() dodaje element na końcu;
• remove() usuwa element po wartości;
• in sprawdza, czy element istnieje;
• not in sprawdza, czy elementu brakuje;
• len() zwraca liczbę elementów;
• listy świetnie współpracują z pętlami;
• listy mogą przechowywać stringi, liczby, booleany i więcej;
• puste listy są przydatne, gdy chcesz dodać dane później;
• pętle mogą budować, czytać, filtrować i przetwarzać listy.

To ogromny krok.

Teraz twoje programy mogą przechowywać wiele wartości.

Mogą przetwarzać kolekcje danych.

Mogą budować listy zakupów.

Mogą obliczać sumy.

Mogą zarządzać zadaniami.

Mogą pracować z wieloma inputami.

To dużo bliżej prawdziwego programowania.

Jedna wartość jest fajna.

Wiele wartości to rzeczywistość.

Następna lekcja

W następnej lekcji nauczymy się słowników.

Słowniki pozwalają przechowywać dane przez klucze i wartości.

Zamiast przechowywać tylko:

["Anna", 25, "Rome"]

będziesz mógł napisać:

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

To bardzo ważne.

Listy są świetne dla wielu wartości.

Słowniki są świetne dla danych strukturalnych.

A dane strukturalne są wszędzie.

Użytkownicy.

Produkty.

Zamówienia.

Profile.

API.

Bardzo użyteczne.

Bardzo Python.