Listy w Pythonie

Listy w Pythonie to struktury danych, które pozwalają przechowywać zbiory elementów w określonej kolejności. Są dynamiczne, co oznacza, że ich rozmiar może się zmieniać w czasie działania programu, i mogą przechowywać elementy różnych typów. Listy są jednymi z najczęściej używanych struktur danych w Pythonie ze względu na ich elastyczność i bogaty zestaw metod.

Podstawowe cechy list w Pythonie

Dynamiczny rozmiar

Listy w Pythonie mogą zmieniać swój rozmiar w trakcie działania programu. Oznacza to, że można do nich dodawać nowe elementy (np. za pomocą metod takich jak append() czy extend()) lub usuwać istniejące (np. używając remove(), pop(), lub del), bez konieczności wcześniejszego określania ich długości. Dzięki temu listy są bardzo elastyczne i idealne do przechowywania dynamicznych zbiorów danych.

Indeksowanie

Listy są indeksowane od 0, co oznacza, że pierwszy element ma indeks 0, drugi 1, itd. Python obsługuje również indeksowanie ujemne, które pozwala odwoływać się do elementów od końca listy (-1 to ostatni element, -2 przedostatni, itd.). Dzięki temu można łatwo i szybko uzyskać dostęp do dowolnego elementu.

Heterogeniczność

W jednej liście można przechowywać elementy różnych typów. Na przykład, w jednej liście można mieć liczby całkowite (int), liczby zmiennoprzecinkowe (float), napisy (str), a nawet inne listy, słowniki czy obiekty. Ta cecha czyni listy uniwersalnym narzędziem do organizacji danych.

example_list = [42, "hello", 3.14, [1, 2, 3]]

Mutowalność

Listy są strukturami danych mutowalnymi, co oznacza, że po ich utworzeniu można zmieniać zawartość bez konieczności tworzenia nowej listy. Możesz modyfikować istniejące elementy, dodawać nowe lub usuwać istniejące. Oto kilka przykładów:

Modyfikacja elementu

my_list = [1, 2, 3]
my_list[0] = 10  # Teraz my_list to [10, 2, 3]

Dodawanie elementu

my_list.append(4)  # Teraz my_list to [10, 2, 3, 4]

Usuwanie elementu

my_list.pop(1)  # Usuwa element o indeksie 1 (wartość 2)

Wsparcie dla zaawansowanych operacji

Listy obsługują różnorodne operacje, takie jak

Slicing (wycinanie)

Umożliwia tworzenie nowych list na podstawie podzbioru elementów z oryginalnej listy.

my_list = [0, 1, 2, 3, 4, 5]
sliced = my_list[1:4]  # Wynik: [1, 2, 3]

Iteracje

Listy można łatwo przechodzić za pomocą pętli for

for item in my_list:
    print(item)

Wbudowane funkcje

len()

Zwraca liczbę elementów w liście.

my_list = [1, 2, 3]
print(len(my_list))  # Wynik: 3

min() i max()

Zwracają najmniejszy i największy element w liście.

numbers = [10, 5, 8]
print(min(numbers))  # Wynik: 5
print(max(numbers))  # Wynik: 10

sum()

Zwraca sumę wszystkich elementów w liście (dotyczy list z liczbami).

numbers = [1, 2, 3]
print(sum(numbers))  # Wynik: 6

sorted()

Zwraca nową listę z posortowanymi elementami oryginalnej listy.

numbers = [3, 1, 2]
print(sorted(numbers))  # Wynik: [1, 2, 3]

reversed()

Zwraca iterator z odwróconą kolejnością elementów listy.

my_list = [1, 2, 3]
print(list(reversed(my_list)))  # Wynik: [3, 2, 1]

enumerate()

Zwraca iterator, który generuje pary indeks-wartość dla elementów listy.

my_list = ['a', 'b', 'c']
for index, value in enumerate(my_list):
    print(index, value)
# Wynik:
# 0 a
# 1 b
# 2 c

map()

Zastosowuje podaną funkcję do każdego elementu listy, zwracając iterator z wynikami.

numbers = [1, 2, 3]
squared = map(lambda x: x**2, numbers)
print(list(squared))  # Wynik: [1, 4, 9]

filter()

Zwraca iterator z elementami listy, które spełniają warunek określony w funkcji.

numbers = [1, 2, 3, 4]
even = filter(lambda x: x % 2 == 0, numbers)
print(list(even))  # Wynik: [2, 4]

zip()

Łączy elementy z dwóch lub więcej list w pary (krotki), tworząc iterator.

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
combined = zip(list1, list2)
print(list(combined))  # Wynik: [(1, 'a'), (2, 'b'), (3, 'c')]

any() i all()

any() zwraca True, jeśli przynajmniej jeden element listy jest prawdziwy, a all() zwraca True, jeśli wszystkie elementy są prawdziwe.

bool_list = [True, False, True]
print(any(bool_list))  # Wynik: True
print(all(bool_list))  # Wynik: False

Wsparcie dla zagnieżdżania

Listy mogą przechowywać inne listy, co pozwala na tworzenie struktur wielowymiarowych, takich jak macierze czy złożone hierarchie danych.

nested_list = [[1, 2], [3, 4], [5, 6]]
print(nested_list[1][1])  # Wynik: 4

Wydajność

Listy w Pythonie są zaimplementowane jako dynamiczne tablice, co oznacza, że operacje takie jak dostęp do elementu za pomocą indeksu są bardzo szybkie (czas O(1)). Dodawanie elementów na końcu jest również wydajne, ale usuwanie lub wstawianie elementów w środku listy może wymagać przesuwania pozostałych elementów, co ma czas O(n).

Możliwość wykorzystania zaawansowanych narzędzi

Python udostępnia różne techniki do operacji na listach, takie jak list comprehension (tworzenie list w jednej linii):

squares = [x**2 for x in range(5)]  # Wynik: [0, 1, 4, 9, 16]

Zewnętrzne biblioteki przydatne do pracy z listami

NumPy

Biblioteka do obliczeń numerycznych, oferująca efektywne operacje na tablicach wielowymiarowych (ndarray), które mogą zastępować listy w zaawansowanych obliczeniach.

import numpy as np
array = np.array([1, 2, 3])
print(array * 2)  # Wynik: [2 4 6]

Pandas

Biblioteka do analizy danych, umożliwiająca tworzenie struktur danych takich jak Series (jednowymiarowe) i DataFrame (dwuwymiarowe), które rozszerzają funkcjonalność standardowych list.

import pandas as pd
series = pd.Series([1, 2, 3])
print(series.mean())  # Wynik: 2.0

itertools

Moduł standardowej biblioteki Pythona oferujący narzędzia do pracy z iteracjami, takie jak generowanie permutacji, kombinacji czy nieskończonych sekwencji.

import itertools
for combination in itertools.combinations([1, 2, 3], 2):
    print(combination)
# Wynik:
# (1, 2)
# (1, 3)
# (2, 3)

collections

Moduł standardowej biblioteki Pythona zawierający specjalne typy danych, takie jak deque (dwustronna kolejka), Counter (licznik elementów) czy defaultdict (słownik z domyślną wartością), które mogą być użyteczne w zaawansowanej pracy z listami.

from collections import Counter
counts = Counter([1, 2, 2, 3, 3, 3])
print(counts)  # Wyn