Zajęcia 4 - Struktury danych, metody

Struktury danych takie jak lista czy krotki (list and tuple) umożliwiają przechowywanie i manipulacje danymi.

Listy

Listy składają się z elementów oddzielonych od siebie przecinkami i umieszczonych w nawiasach kwadratowych. Elementy zawierające się w liście mogą mieć różne typy.

my_list = [1, 2, 3, 4, 5]

Elementy w liście posiadają indeksy. Należy pamiętać, że indeksy w Pythonie liczone są od 0 !

my_list[0] # returns first element - 1
my_list[4] # returns fifth element - 5 
my_list[-1] # returns last element - 5

Listy mogą też być cięte (sliced). Wszystkie operacje wycinania zwracają nową listę zawierającą żądane elementy. Oznacza to, że poniższy fragment kodu zwraca płytką kopię listy.

my_list[0:3] # gives first, second and third element of te list
my_list[2:] # returns from second to the last element of the list
my_list[-3:] # return third element from the end to the last 

print(f"oryginalna lista: {my_list}") # returns [1, 2, 3, 4, 5]

new_list = my_list[1:3]
print(f"pocięta lista: {new_list}") #returns [[2, 3]

print(f"oryginalna lista2: {my_list}") # returns [1, 2, 3, 4, 5]

Listy można ze sobą łączyć:

my_list + [6, 7, 8] # returns [1, 2, 3, 4, 5, 6, 7, 8]

Istnieje możliwość zmiany zawartości listy - oznacza to że są mutowalne (mutable):

my_list[2] = 9 # returns [1, 2, 9, 4, 5]

Przypisanie do wycinków jest również możliwe, i może to nawet zmienić rozmiar listy lub całkowicie ją wyczyścić.

my_list[2:4] = [6, 7, 8] # returns [1, 2, 6, 7, 8, 5]
my_list[:] = [] #reurns []

Ważne, żeby zapamiętać, że proste przypisanie w Pythonie nigdy nie kopiuje danych. Gdy lista zostanie przypisana do zmiennej, zmienna odnosi się do istniejącej listy. Wszelkie zmiany, które zostaną wprowadzone w liście za pomocą jednej zmiennej, będą widoczne przez wszystkie inne zmienne, które się do niej odnoszą.

Często używaną i przydatną funkcją jest funkcja len() - zwraca ona długość tablicy:

len(my_list) #returns 5

Przykładowe metody list

Krotki (tuple)

Krotki w Pythonie to rodzaj struktury danych podobnej do list, ale z jedną kluczową różnicą: krotki są niemutowalne, co oznacza, że raz utworzone, nie można ich zmieniać.

Kilka kluczowych cech krotek:

• Niemutowalne: Po utworzeniu krotki nie można zmieniać jej zawartości — nie można dodawać, usuwać ani modyfikować elementów.
• Tworzenie krotek:

• Pustą krotkę tworzy się za pomocą nawiasów: ().
• Krotkę z jednym elementem tworzy się dodając przecinek po elemencie: a, lub (a,).
• Krotki z wieloma elementami można tworzyć, oddzielając elementy przecinkami: a, b, c lub (a, b, c).
• Używając tuple()

• Wygodna do przechowywania stałych danych: Krotki są często używane do przechowywania danych, które nie powinny się zmieniać, takich jak współrzędne punktu (x, y), daty, czy wartości zwracane przez funkcję.
• Szybsze niż listy: Ponieważ krotki są niemutowalne, operacje na nich mogą być szybsze niż na listach.
• Mogą zawierać różne typy danych: Krotki mogą przechowywać różne typy danych (np. liczby, stringi, inne krotki), co czyni je użytecznymi do przechowywania zróżnicowanych informacji. - ciekawe jest że w krotce można przechowywać mutowalne elementy

Przykładowe metody:

Sets

To nieuporządkowana kolekcja bez elementów powtarzających się. Podstawowe zastosowania obejmują testowanie przynależności i eliminowanie duplikatów. Obiekty zbiorów obsługują także operacje matematyczne, takie jak suma, przecięcie, różnica i różnica symetryczna.

Do tworzenia setów używa się nawiasów klamrowych {} bądź funkcji set()

numbers = {1, 1, 2, 3, 4, 4, 4, 5, 6}
print(numbers) # {1, 2, 3, 3, 5, 6}

a = set('abracadabra')
b = set('alacazam')

a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
a - b                              # letters in a but not in b
{'r', 'd', 'b'}
a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
a & b                              # letters in both a and b
{'a', 'c'}
a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

Słownik

Słowniki w Pythonie to jedna z podstawowych struktur danych, która pozwala na przechowywanie par klucz-wartość. Oto kluczowe cechy i zastosowania słowników:

Cechy słowników:

1. Nieuprządkowana kolekcja: Słowniki są nieuporządkowane, co oznacza, że nie zapisują kolejności, w jakiej elementy zostały dodane.
2. Unikalne klucze: Każdy klucz w słowniku musi być unikalny. Jeśli spróbujesz dodać nowy element z kluczem, który już istnieje, wartość dla tego klucza zostanie zaktualizowana.
3. Haszowalne klucze: Klucze muszą być haszowalne, co oznacza, że muszą być typu niezmienniczego (immutable). Typowe przykłady to liczby, napisy (strings), krotki (tuples) zawierające tylko niemutowalne elementy. Listy, słowniki i inne zbiory nie mogą być używane jako klucze, ponieważ są mutowalne.
4. Mutowalne wartości: Wartości w słownikach mogą być dowolnego typu i są mutowalne. Możesz przechowywać w słowniku liczby, napisy, listy, inne słowniki itp.

Tworzenie słowników:

• Przez użycie nawiasów klamrowych
• Przez użycie funkcji dict()
• Przez konwersję z listy krotek: my_dict = dict([('name', 'Alice'), ('age', 30), ('city', 'New York')])

Operacje na słownikach:

• dodawanie i aktualizowanie elementów:

my_dict["name"] = "natalia" #dodaje nowy element z kluczem "name" i wartością "natalia"

• usuwanie elementów

del my_dict["name"]
name = my_dict.pop("name") # usuwa klucz i zwraca jego wartość
last_item = my_dict.popitem() # usuwa ostatni dodany element i zwraca go jako krotkę

• sprawdzenie istnienia klucza

if "name" in my_dict:
  print("klucz istnieje"

• iterowanie po kluczach i wartościach

for key in my_dict:
  print(key, my_dict[key]

for key, value in my_dict.items()
  print(key, value)

• odczytywanie wartości

name = my_dict.get("name")