Manipulowanie danymi w języku Python nie ogranicza się do struktur prostych wartości, czy list. W niniejszym materiale uporządkujemy sobie nieco informacje o tych strukturach. Jest to przydatne przed przejściem na wyższy poziom tj. do klas.
Wartości proste zapisywane są w zmiennych w sposób przyporządkowania wartości będącej jednym z typów: całkowitych [int], zmiennoprzecinkowych [double], logicznych [boolean], ciągów znakowych [str]. W ten sposób tworzy się obiekt, którego jedną z cech jest interesująca nas wartość do której odnosimy się w naszych programach. Typy złożone są przypisaniem struktury składającej się z wielu typów prostych lub innych typów złożonych. Założeniem ich istnienia jest albo elastyczne zarządzanie wieloma elementami potrzebnymi nam w programie, albo zgrupowanie określonych danych w jednej strukturze np. dla ich archiwizacji w pliku.
Do tej pory nie nazywaliśmy ich zbytnio i używaliśmy ich podchodząc do tego tematu intuicyjnie. Najwyższy czas by porozmawiać o tych strukturach. Dokumentacja Pythona przewiduje ich kilka rodzajów w zależności od potrzeb programistycznych. Na pierwszy ogień pójdzie nowa struktura, a mianowicie słowniki.
Dict – słowniki
Są one bardzo użytecznym elementem, który umożliwia wprowadzenie do programu przyporządkowanych par:: klucz:wartość. Używając w kodzie programu <<klucza>>, umieszcza się z automatu jego wartość. Najprostszym chyba przykładem dla zrozumienia słowników jest liczba Pi1nie musimy w Pythonie tworzyć nowego przyporządkowania dla Pi, bo już istnieje w module math.pi, ale stanowi ta liczba dobry przykład tutaj.. Możemy stworzyć słownik stałych matematycznych, wartości charakterystycznych dla np. branży budowlanej itp., których wartości będą określone z góry, i do których będziemy mogli się w programie odwoływać.
slownik = { 'Pi':3.14159}
print(slownik['Pi'])
Można także na tej podstawie stworzyć np. prostą książkę telefoniczną:
telefony = { 'Tomek':601342665, 'Marek':785444918, 'Jola':501667582}
print(telefony['Marek'].__format__('_'))
lub odnieść się to wspomnianych już danych budowlanych tworząc słownik… klas betonu2Przykład pożyczony z: https://oprojektowaniu.pl/python-dla-inzynierow-slowniki/.
# Klasy betonu wg EC2
concrete_fck = {'C20/25': 20, 'C25/30': 25}
# I teraz łatwo można sprawdzić jaką wartość fck ma dana klasa betonu, np.:
print(concrete_fck['C25/30']) # wywołanie watości fck odpowiadającej danej klasie betonu
# Sprawdzenie ilości elementów słownika:
print(f'Ilość elementów słownika o betonie to {concrete_fck.__len__()}')
#Sprawdzenie czy słownik zawiera taki klucz:
print(f'Czy w słowniku znajduje się klasyfikacja betonu C25/30? {concrete_fck.__contains__('C25/30')}')
#Dodawanie nowej pary do słownika:
concrete_fck['C30/37']= 30 ##UWAGA: concrete_fck={'C30/37',30} to skasowanie poprzedniego słownika i stworzenie nowego z 1 elementem!
#Skasowanie jednego klucza (z jego wartością) ze słownika
del(concrete_fck['C30/37'])
#Wypisanie wszystkich kluczy i ich wartości
print(*concrete_fck.keys())
print(*concrete_fck.values())
Zadanie 1: Zaproponuj własną strukturę słownikową
Należy pamiętać, że klucze w słowniku muszą być unikalne. Próba przypisania pary z kluczem już istniejącym, to de facto nadanie nowej wartości kluczowi.
List – listy
Listy zawierają elementy oraz metody manipulacji nimi… i to jest najprostsza definicja listy.
zebrane_owoce=['jabłko','gruszka','gruszka','jabłko','jabłko']
# błędna próba dodawania elementów do listy!
zebrane_owoce.__add__(['śliwka'])
#poprawna metoda dodawania elementów do listy
zebrane_owoce.append('śliwka')
#wyświetlenie elementów i ilości elementów na liście
print(*zebrane_owoce)
print(zebrane_owoce.__len__())
#Wyświetlenie pierwszego wystąpienia elementu o wskazanej wartości
print(zebrane_owoce.index('gruszka'))
#Policzenie ile jest elementów o tej samej wartości w liście
print(zebrane_owoce.count('gruszka'))
#sortowanie listy
zebrane_owoce.sort()
print(*zebrane_owoce)
#sortowanie malejące
zebrane_owoce.reverse()
#usunięcie elementu spełniającego warunek, że jesz to 'gruszka'
zebrane_owoce.remove('gruszka')
#pobranie/zdjęcie (czyli usunięcie go) ostatniego elementu z listy
print(zebrane_owoce.pop())
#pobranie/zdjęcie 4 elementu na liście
print(zebrane_owoce.pop(3))
Dostępne metody – te najczęściej potrzebne przedstawione są na powyższych przykładach.
Zadanie 2: Stwórz przykładową listę, dodaj do niej minimum 20 elementów; 10 w programie, i kolejne poprzez odpytanie użytkownika z klawiatury.
a) Niech program sprawdzi, czy są duplikaty na liście, jeśli tak – usunie je,
b) Niech program poda liczbę kardynalną (moc zbioru) pierwotnej listy, a następnie liczbę kardynalną listy zredukowanej (bez duplikatów),
c) Niech program poda dla każdego elementu listy ilość duplikatów, jakie posiadała lista pierwotna.
Set – kolekcja
Kolekcja jest podobna do listy, jest nieuporządkowanym zbiorem różnych elementów. Ważną różnicą jest to, że nie posiada zduplikowanych elementów. Próba dodania do kolekcji elementu, który już w niej jest umieszczony kończy się brakiem efektu.
zebrane_owoce={'jabłko','gruszka','gruszka','jabłko','jabłko','pomarańcza','truskawka','arbuz'}
print(*zebrane_owoce)
Ciekawym jest proces tworzenia set’u – wystarczy uruchomić powyższy program kilkukrotnie i zaobserwować wyniki.
#test czy malina jest w kolekcji:
if ('malina' in zebrane_owoce): print("malina jest w secie")
else: print("maliny brak")
Tworzenie set’u jest też możliwe jako obiekt pusty za pomocą polecenia set(). Tak samo tworzymy set z wykorzystaniem tegoż polecenia:
zestaw=set({'pamięć','pamięć','płyta główna','procesor','karta grafiki','SSD'})
#set nie ma możliwości posortowania elementów, ale nic nie szkodzi, abyśmy stworzyli tę możliwość na potrzeby nasze sortując pobraną listę elementów set'u (sortujemy listę, nie set)
print(*sorted(zestaw,reverse=True),sep=', ')
print(*zestaw,sep=', ')
Optymalizowane zadania wykonywane na setach umożliwiają szybkie i efektywne stworzenie np. alfabetu (znaków użytych w) ciągu.
alfabet=set('Ala ma kota Bonifacego, a kot ma mysz imieniem Zofia')
print(*sorted(alfabet))
###wynik poniżej:
, A B Z a c e f g i k l m n o s t y z
### Uwaga: spacja jest też znakiem użytym.
Sety są idealnym materiałem do realizacji matematycznych operacji na zbiorach – umożliwiają sumowanie zbiorów, przecięcie zbioru (część wspólna), różnicę zbioru, różnicę symetryczną itp.
################################### przecięcie dwu zbiorów (AND)
#Stwórz alfabet ciągu zgodny z literami alfabetu nierozróżniający wielkości liter.
import string
zdanie=str.lower("Ala ma kota Bonifacego, a kot ma mysz imieniem Łucja, którą się często bawi...")
alfabet=set(zdanie)
print(*sorted(alfabet & set(string.ascii_lowercase)),sep=', ')
###wynik poniżej:
a, b, c, e, f, g, i, k, l, m, n, o, s, t, y, z
####################### Ale UWAGA:
Należy zauważyć, że są to tylko litery alfabetu łacińskiego, bez polskich znaków...
Zatem aby poprawnie zrealizować powyższe zadanie należy nie używać string.ascii_lowercase, ale zdefiniować własny set liter z polskimi włącznie:
polskieLitery=set("aąbcćdeęfghijklłmnoóprstwyzżź")
zdanie=str.lower("Ala ma kota Bonifacego, a kot ma mysz imieniem Łucja, którą się często bawi...")
alfabet=set(zdanie)
print(*sorted(alfabet & polskieLitery),sep=', ')
###Wynik poniżej:
a, b, c, e, f, g, i, j, k, l, m, n, o, r, s, t, w, y, z, ó, ą, ę, ł
################################### suma dwu zbiorów (OR)
set_nieparzystych={1,3,5,7,9}
set_parzystych={0,2,4,6,8}
print(*sorted(set_parzystych | set_nieparzystych ),sep=', ')
#Wynik: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
################################### różnica dwu zbiorów
set_10int=set(range(0,10))
set_nieparzystych={1,3,5,7,9}
set_parzystych={0,2,4,6,8}
print(*sorted(set_10int - set_nieparzystych ),sep=', ') #pierwszy sposób
print(*set_10int.difference(set_nieparzystych),sep=', ') #drugi sposób
#Wynik: 0, 2, 4, 6, 8
################################### różnica symetryczna (XOR - ALBO)
print(*set(set_10int ^ set_nieparzystych),sep=', ') # trzeci sposób na poprzednie zadanie z wykorzystaniem różnicy symetrycznej
#Wynik: 0, 2, 4, 6, 8
###################################
zdanie1=set('ABECADŁO')
zdanie2=set('CAD')
print(*sorted(zdanie1 ^ zdanie2 ),sep=', ')
#Wynik: B, E, O, Ł
Zadanie 3: Niech program pobiera dwa zdania od operatora.
Napisz procedurę obliczającą Indeks Jaccarda dla tych zbiorów (podobieństwo),
Zadanie 4: Niech program pobiera od użytkownika dowolne zdanie.
Napisz procedurę obliczającą Współczynnik Sørensena dla dwu próbek pod względem użycia spółgłosek i samogłosek
Tuples – krotki
Krotki są kolejną strukturą umożliwiającą przechowywanie danych. Elementy dodane w krotce są uporządkowane (indeksowane)3Nie mylić z posortowanymi! i nieusuwalne (elementy w krotce nie mogą być usuwane). Krotki dopuszczają dodawanie w nich wielokrotnie tej samej wartości, co znaczy, że w przeciwieństwie do set’ów zezwalają na duplikaty.
krotka=("Ala",)
Powyższy przykład jest metodą tworzenia krotki zawierającej jeden element – ciąg tekstowy “Ala”. Zauważyłeś na końcu znak przecinka?! Zaeksperymentuj i usuń go. Czy widzisz zmianę?!
krotka=("Ala",)
print(krotka[0])
print(krotka[1])
# brak elementu 2 powoduje wygenerowanie błędu... Można to estetycznie obsłużyć jak w przykładzie poniżej:
krotka=("Ala",)
try:
print(krotka[0])
print(krotka[1])
except IndexError: print("Nie ma już co wyświetlać...")
#Wprowadzenie liter ciągu jako elementy krotki.
krotka=("Ala")
print(krotka[0])
print(krotka[1])
Należy pamiętać, że podanie jednego elementu dla stworzenia krotki może mieć w przypadku użycia ciągu tekstowego inne znaczenie. Taki ciąg zostanie potraktowany jako źródło wejścia, a krotka zostanie stworzona jako zbiór liter będących rozbiciem tego ciągu na znaki. Dlatego też istotnym jest, aby w takiej sytuacji użyć znaku przecinka po jedynym elemencie. Sygnalizujemy wtedy, że jest to krotka jednoelementowa zawierająca ciągi znakowe. Krotka może zawierać elementy dowolnego typu. Nie muszą być monogeniczne. Może zawierać np.: ciąg tekstowy i liczby. Krotka jest też w zasadzie podstawową strukturą wieloelementową w #Python – używaliśmy jej w naszych przykładach od początku kursu.
Podsumowanie
W języku programowania Python istnieją cztery typy danych kolekcji:
- Słownik (Dict) to kolekcja uporządkowana* i zmienna. Brak duplikatów elementów.
- Lista (List) to kolekcja uporządkowana i zmienna. Dopuszcza duplikaty elementów.
- Zbiór (Set) to kolekcja nieuporządkowana, niezmienna** i nieindeksowana. Brak duplikatów elementów.
- Krotka (Tuple) to kolekcja uporządkowana i niezmienna. Dopuszcza duplikaty elementów.
* Od wersji Pythona 3.7 słowniki są uporządkowane. W Pythonie 3.6 i starszych słowniki nie są uporządkowane.
**Elementy zestawu są niezmienne, ale możesz je usuwać i/lub dodawać w dowolnym momencie.
A… tablice?!
Cóż, w języku #Python kolekcje wyżej wymienione są traktowane jako odpowiedniki tablic (Arrays) z funkcjonalnymi usprawnieniami… Dla dociekliwych jest biblioteka array oraz NumPy zawierająca obsługę wielowymiarowych struktur numerycznych wraz funkcjami do ich przetwarzania4NumPy to podstawowy pakiet do obliczeń naukowych w Pythonie. Jest to biblioteka Pythona, która udostępnia wielowymiarowe obiekty tablicowe, różne obiekty pochodne (takie jak tablice maskowane i macierze) oraz dostarcza zestaw procedur do szybkich operacji na tablicach, w tym matematycznych, logicznych, manipulacji kształtami, sortowania, zaznaczania, operacji wejścia/wyjścia, dyskretnych transformat Fouriera, podstawowej algebry liniowej, podstawowych operacji statystycznych, symulacji losowej i wielu innych..
Comments are closed