Od zera do mistrza Big Data i uczenia maszynowego w Pythonie. Część 3

    No Comments

    Po zapoznaniu się z podstawowymi typami zmiennych skalarnych warto zdobyć wiedzę o  typach sekwencyjnych

    Należą do nich głównie

    • Listy (lists)
    • Krotki (tuples)
    • Słowniki (dictionaries)
    • Zbiory  (sets)

    Dzielimy je na zmienialne (mutable) i  niezmienialne (immutable)

    Listy i zbiory, słowniki są przedstawicielami tej pierwszej grupy, a krotki i , napisy i zbiory niezmienne (frozenset) są przedstawicielami tej drugiej..
    Typów niezmienialnych nie można bezpośrednio modyfikować
    Postanowiłem poświęcić na początek nieco uwagi na rozszerzenie wiedzy o napisach, sposobie indeksowania i generowania podciągów.
    Warto zapamiętać: Indeksy zaczynamy od zera, więc pierwszy element zmiennej napisowej s to s[0], ostatni to s[len[s]-1]. Mamy też do dyspozycji indeksy ujemne  s[-1] to ostatni element napisu, a s[-len(s)] pierwszy.

    Ważne jest uzmysłowienie sobie informacji o tym, że Python jest nie tylko dynamicznie typowany, ale również silnie typowany, dlatego musimy uważać na wszelkie konwersje typów. Poniżej prosty kod, na trzy instrukcje print, tylko jedna wykona się poprawnie.

    https://www.python.org/dev/peps/pep-0020/
    The Zen of Python: “Explicit is better than implicit.”

    Postaram się utrwalić rzutowanie, nie tylko między zmiennymi skalarnymi, ale również sekwencyjnymi.

    Notatnik umieszczony na GitHub

    Podgląd:

    https://nbviewer.jupyter.org/github/djkormo/PythonForML/blob/master/intro/Kurs_2_typy_sekwencyjne_iterowane.ipynb

    Uruchomienie:

    https://mybinder.org/v2/gh/djkormo/PythonForML/master?filepath=intro/Kurs_2_typy_sekwencyjne_iterowane.ipynb

    Po uruchomieniu kontenera należy wyczyścić informacje wyjściowe za pomocą menu Kernel -> Restart & Clear Output.

    Reenderowane wtyczką WP:

    Indeksowanie

    In [1]:
    # deklarujemy zmienną s1 typu napis 
    
    s1="Witamy na kursie Pythona."
    print('Napis s : ',s1)
    
    #pierwszy element napisu oznaczamy cyfra 0 []
    
    print ("\nIndeksowanie dodatnie:\n")
    
    print('Pierwszy element napisu s1 : ',s1[0])
    
    # drugi element [1]
    
    print('Drugi element napisu s1 : ',s1[1])
    
    # trzeci element [2]
    
    print('Trzeci element napisu s1 : ',s1[2])
    
    
    # ostatni element napisu [dlugosc -1]
    
    print('Ostatni element napisu s1 : ',s1[len(s1)-1])
    
    print ("\nIndeksowanie ujemne:\n")
    
    # mozna tez wykorzystac indeksy ujemne
    
    
    # ostatni element [-1]
    
    print('Ostatni element napisu s1 : ',s1[-1])
    
    # przedostatni element [-2]
    
    print('Przedostatni element napisu s1 : ',s1[-2])
    
    # pierwszy element [-dlugosc]
    
    print('Pierwszy element napisu s1 : ',s1[-len(s1)])
    
    Napis s :  Witamy na kursie Pythona.
    
    Indeksowanie dodatnie:
    
    Pierwszy element napisu s1 :  W
    Drugi element napisu s1 :  i
    Trzeci element napisu s1 :  t
    Ostatni element napisu s1 :  .
    
    Indeksowanie ujemne:
    
    Ostatni element napisu s1 :  .
    Przedostatni element napisu s1 :  a
    Pierwszy element napisu s1 :  W
    

    Tworzenie podciagów

    In [2]:
    # tworzenie podciagow (slice)
    
    s1="Witamy na kursie Pythona."
    print('Oryginalny napis ',s1, ' o długości ',len(s1))
    
    # tworzymy podciag zaczynajacy sie od indeksu [1]  do ponizej indeksu [2]
    
    print ('Drugi element o indeksie [1] : ',s1[1:2]) # wyswietlamy tylko element drugi - indeks [1]
    
    # ogolna postac [a:b:c] 
    # a oznacza indeks elementu startowego, 
    # b oznacza gorny indeks elementu, ktory nas nie interesuje
    # c oznaccza roznice miedzy kolejnymi indeksami
    
    # domyslnie a =0, b =len(napis), c  = 1
    
    # wyswietlenie wzystkich elementow napisu
    
    print('Wszystkie elementy napisu s1 : ',s1[::])
    
    
    # wyswietlanie co drugiego elementu napisu
    
    print('Co drugi element napisu s1 : ',s1[::2])
    
    # krok zmiany moze byc tez ujemny
    
    print('Napis s1 w odwrotnej kolejności : ',s1[::-1])
    
    # co drugi element w odwrotnej kolejnosci
    
    print('Co drugi element napisu s1 w odwrotnej kolejnosci : ',s1[::-2])
    
    Oryginalny napis  Witamy na kursie Pythona.  o długości  25
    Drugi element o indeksie [1] :  i
    Wszystkie elementy napisu s1 :  Witamy na kursie Pythona.
    Co drugi element napisu s1 :  Wtm akri yhn.
    Napis s1 w odwrotnej kolejności :  .anohtyP eisruk an ymatiW
    Co drugi element napisu s1 w odwrotnej kolejnosci :  .nhy irka mtW
    

    Listy [lists]

    LIsty sa obiektami sekwencyjnymi zmienialnymi (mutable)

    In [1]:
    # listy tworzymy za pomoca nawiasów kwadratowych []
    
    lista1=[1,2,'Ala',4]
    print('Lista lista1 : ',lista1,type(lista1))
    
    # elementy listy nie musze byc tego samego typu
    
    # utworzmy pusta liste, warto pamietac ze konwersja takiej listy na typ logiczny zwraca falsz
    
    lista2=[]
    
    print('Lista lista2 : ',lista2,type(lista2),bool(lista2))
    
    # indeksowanie elementow analogiczne jak dla napisow
    
    print(lista1, lista1[1])  #  "[1, 2, 'Ala', 4]"
    print(lista1[-1])     # Wyswietla ostatni element listy
    lista1[3] = 'ma'      # Zmiana elementu o indeksie [3] 
    print('Lista lista1 : ',lista1)         #  wyswietla "[1, 2, 'Ala', 'ma']"
    
    # dedykowane dla list metody
    
    lista1.append('kota') # Dodajemy element listy na jej koncu
    print('Lista lista1 : ',lista1)         # "[1, 2, 'Ala', 'ma', 'kota']"
    
    
    lista11 = lista1.pop()    # Odczytanie ostatniego elementu listy z jednoczesnym usunieciem
    print('Lista lista11 : ',lista11,'Lista lista1 : ', lista1)      # kota [1, 2, 'Ala', 'ma']
    
    # lista w odwrotnej kolejnosci
    
    lista1rev=lista1[::-1]
    print('Lista lista1rev : ',lista1rev)      # kota [1, 2, 'Ala', 'ma']
    
    # dodanie nowego elementu listy w pozycji o indeksie 2, w szczegolnosci moze byc to kolejna lista
    
    lista12 = lista1.insert(2,['Basia','ma','psa'])
    print('Lista lista12 : ',lista12,' o liczbie elementow : ', lista12)
    
    
    # liczba elementow listy
    print('Lista lista1 : ',lista1, 'o liczbe elementow : ',len(lista1))
    
    # dodawanie list
    
    lista3 = lista1 +lista1
    print('Lista lista3 : ',lista3, 'o liczbie elementow : ',len(lista3))
    
    # mnozenie listy przez wartosc z prawej strony
    
    lista4=lista3[:4:1]*2;
    print('Lista lista4 : ',lista4, ' o liczbie elementow : ',len(lista4))
    
    # mnozenie listy przez wartosc z lewej strony
    
    lista5=2*lista3[:3:1];
    print('Lista lista5 : ',lista5,' o liczbie elementow : ',len(lista5))
    
    Lista lista1 :  [1, 2, 'Ala', 4] <class 'list'>
    Lista lista2 :  [] <class 'list'> False
    [1, 2, 'Ala', 4] 2
    4
    Lista lista1 :  [1, 2, 'Ala', 'ma']
    Lista lista1 :  [1, 2, 'Ala', 'ma', 'kota']
    Lista lista11 :  kota Lista lista1 :  [1, 2, 'Ala', 'ma']
    Lista lista1rev :  ['ma', 'Ala', 2, 1]
    Lista lista12 :  None  o liczbie elementow :  None
    Lista lista1 :  [1, 2, ['Basia', 'ma', 'psa'], 'Ala', 'ma'] o liczbe elementow :  5
    Lista lista3 :  [1, 2, ['Basia', 'ma', 'psa'], 'Ala', 'ma', 1, 2, ['Basia', 'ma', 'psa'], 'Ala', 'ma'] o liczbie elementow :  10
    Lista lista4 :  [1, 2, ['Basia', 'ma', 'psa'], 'Ala', 1, 2, ['Basia', 'ma', 'psa'], 'Ala']  o liczbie elementow :  8
    Lista lista5 :  [1, 2, ['Basia', 'ma', 'psa'], 1, 2, ['Basia', 'ma', 'psa']]  o liczbie elementow :  6
    

    Konwersja typow dla list

    In [3]:
    # konwersja na typ listy -> list(obiekt)
    
    # zamiana napisu na liste, kazdy z elementow napisu jest zamieniony na element listy
    
    s1='Ala ma kota, a Basia ma psa.';
    l1=list(s1)
    print('Lista l1 : ',l1,' o liczbie elementow: ',len(l1))
    
    # konwersja z listy na napis, 
    
    s2=''.join(l1)
    print('Napis s2 : ',s2, ' o dlugosci : ',len(s2))
    
    # type range, bedziemy z niego intensywnie korzystac przy petlach, domyslny krok 1.
    
    r1=range(50) # generujemy liczby od zera do najwiekszej mniejszej niz 50
    print('Sekwencja r1 : ',r1, type(r1),' liczba elementow : ',len(r1)) # <class 'range'>
    
    r2=range(-20,20) # generujemy liczby od -20 do najwiekszej mniejszej niz 20
    print('Sekwencja r2 : ',r2, type(r2),' liczba elementow : ',len(r2)) # <class 'range'>
    
    r3=range(-20,20,2) # generujemy liczby od -20 do najwiekszej mniejszej niz 20 co krok rowny 2
    print('Sekwencja r3 : ',r3, type(r3),' liczba elementow : ',len(r3)) # <class 'range'>
    
    
    # zamiana na liste
    
    lr1=list(r1)
    print('Lista lr1 : ',lr1, type(lr1)) # <class 'list'>
    lr2=list(r2)
    print('Lista lr2 : ',lr2, type(lr2)) # <class 'list'>
    lr3=list(r3)
    print('Lista lr3 : ',lr3, type(lr3)) # <class 'list'>
    
    Lista l1 :  ['A', 'l', 'a', ' ', 'm', 'a', ' ', 'k', 'o', 't', 'a', ',', ' ', 'a', ' ', 'B', 'a', 's', 'i', 'a', ' ', 'm', 'a', ' ', 'p', 's', 'a', '.']  o liczbie elementow:  28
    Napis s2 :  Ala ma kota, a Basia ma psa.  o dlugosci :  28
    Sekwencja r1 :  range(0, 50) <class 'range'>  liczba elementow :  50
    Sekwencja r2 :  range(-20, 20) <class 'range'>  liczba elementow :  40
    Sekwencja r3 :  range(-20, 20, 2) <class 'range'>  liczba elementow :  20
    Lista lr1 :  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49] <class 'list'>
    Lista lr2 :  [-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] <class 'list'>
    Lista lr3 :  [-20, -18, -16, -14, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18] <class 'list'>
    

    Krotki (tuples)

    Krotki sa elementami sekwencyjnymi niezmienialnymi (immutable)

    In [4]:
    # krotki tworzymy za pomoca nawiasów zwyklych ()
    
    k1= 1,3,5,'Pies'
    print(k1,type(k1))
    
    # W szczegolnosci mozemy tworzyc krotki bez wykorzystania ()
    
    k2 = 1,2,3,4,'Ala','ma','kota'
    print(k2,type(k2))
    
    # pusta krotka, konwertowalna na typ logiczny jako falsz
    
    k3=()
    
    print(k3,type(k3),bool(k3))
    
    # budowa krotki z jednym elementem
    
    k4a=(1)
    print(k4a,type(k4a)) # 1 <class 'int'>
    
    # w takim przypadku, nalezy postawic znak , po wartosci pierwszego/ostatniego elementu
    
    k4b=(1,)
    print(k4b,type(k4b)) # (1,) <class 'tuple'>
    
    (1, 3, 5, 'Pies') <class 'tuple'>
    (1, 2, 3, 4, 'Ala', 'ma', 'kota') <class 'tuple'>
    () <class 'tuple'> False
    1 <class 'int'>
    (1,) <class 'tuple'>
    
    In [5]:
    # dostep do elementow krotki  analogicznie jak do elementow listy
    
    k5=('Ala','ma','kota',3.14,12,2.0)
    print('Zawartosc krotki k5 : ',k5)
    print('Pierwszy element krotki k5: ',k5[0])
    
    print('Ostatni element: ',k5[-1])
    
    # dostep do elementow krotki 
    
    krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
    krotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)
    
    print ("krotka1[0]: ", krotka1[0])
    print ("krotka2[1:5]: ", krotka2[1:5])
    
    Zawartosc krotki k5 :  ('Ala', 'ma', 'kota', 3.14, 12, 2.0)
    Pierwszy element krotki k5:  Ala
    Ostatni element:  2.0
    krotka1[0]:  Poznan
    krotka2[1:5]:  (2, 3, 4, 5)
    
    In [6]:
    # modyfikacja elementu krotki
    
    krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
    
    krotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment
    
    # krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu
    
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-6-4dac655d56c5> in <module>()
          3 krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
          4 
    ----> 5 krotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment
          6 
          7 # krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu
    
    TypeError: 'tuple' object does not support item assignment
    In [7]:
    krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
    krotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)
    
    krotka3=krotka1+krotka2
    print('Zawartosc krotka1 : ',krotka1,' o dlugosci :',len(krotka1))
    print('Zawartosc krotka2 : ',krotka2,' o dlugosci :',len(krotka2))
    print('Zawartosc krotka3 : ',krotka3,' o dlugosci :',len(krotka3))
    
    Zawartosc krotka1 :  ('Poznan', 'Warszawa', 1995, 2018)  o dlugosci : 4
    Zawartosc krotka2 :  (1, 2, 3, 4, 5, 6, 7, 8)  o dlugosci : 8
    Zawartosc krotka3 :  ('Poznan', 'Warszawa', 1995, 2018, 1, 2, 3, 4, 5, 6, 7, 8)  o dlugosci : 12
    

    Dodatkowe operacje na krotkach

    In [8]:
    # Sortowanie
    
    # kwotka nieposortowana
    
    osoby = ('Alicja','Magda','Izabella','Agnieszka','Jadwiga')
    print('Krotka osoby :', osoby)
    
    # sortowanie krotki osoby
    
    osoby = tuple(sorted(osoby))
    
    print('Krotka osoby po sortowaniu :', osoby)
    
    Krotka osoby : ('Alicja', 'Magda', 'Izabella', 'Agnieszka', 'Jadwiga')
    Krotka osoby po sortowaniu : ('Agnieszka', 'Alicja', 'Izabella', 'Jadwiga', 'Magda')
    

    Konwersja typow dla krotek

    In [9]:
    listax = [1,5,3,6]
    
    # konwersja na krotke za pomoaca funkcji tuple()
    
    krotkax = tuple(listax)
    print('Krotkax : ',krotkax,type(krotkax),'liczba elementow : ',len(krotkax))
    
    # sortowanie 
    krotkax = tuple(sorted(listax))
    print('Krotkax po sortowaniu: ',krotkax,type(krotkax),'liczba elementow : ',len(krotkax))
    
    Krotkax :  (1, 5, 3, 6) <class 'tuple'> liczba elementow :  4
    Krotkax po sortowaniu:  (1, 3, 5, 6) <class 'tuple'> liczba elementow :  4
    

    Slowniki {dictionaries}

    In [10]:
    # słowniki przechowuja  zestawy par klucz-wartość
    
    #tworzymy pusty słownik, rzutowany na typ logiczny daje wartość fałszu
    
    slownik1={}
    
    print(slownik1,type(slownik1),bool(slownik1)) # {} <class 'dict'> False
    
    # dodajemy pierwsza parę do pustego słownika
    
    slownik1['wzrost']=187
    
    # dodajemy druga pare
    
    slownik1['kolor']='blond'
    
    print(slownik1,len(slownik1)) # {'wzrost': 187, 'kolor': 'blond'} 2
    
    # klucz jest unikalny w ramach slownika
    
    # zmiana wartosci dla klucza, takie podstawienie niszczy poprzednia wartość
    slownik1['wzrost']=190
    
    print(slownik1,len(slownik1)) # {'wzrost': 190, 'kolor': 'blond'} 2
    
    # usuniecie pary klucz-wartosc
    
    del slownik1['wzrost']
    
    print(slownik1,len(slownik1)) # {'kolor': 'blond'} 1
    
    
    # dodanie po raz kolejny pary {'wzrost':1}
    slownik1['wzrost']=190
    
    # zauważmy zmianę kolejności kluczy
    print(slownik1,len(slownik1)) # {'kolor': 'blond', 'wzrost': 190} 2
    
    # wyczyszczenie zawartości słownika
    
    slownik1.clear()
    
    print(slownik1,len(slownik1)) # {} 0
    
    {} <class 'dict'> False
    {'wzrost': 187, 'kolor': 'blond'} 2
    {'wzrost': 190, 'kolor': 'blond'} 2
    {'kolor': 'blond'} 1
    {'kolor': 'blond', 'wzrost': 190} 2
    {} 0
    
    In [11]:
    #usunięcie obiektu 
    
    del slownik1
    
    print(slownik1,len(slownik1)) # NameError: name 'slownik1' is not defined
    
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-11-3a1d850715e0> in <module>()
          3 del slownik1
          4 
    ----> 5 print(slownik1,len(slownik1)) # NameError: name 'slownik1' is not defined
    
    NameError: name 'slownik1' is not defined
    In [12]:
    # tworzymy slownik z trzema parami klucz-wartosc
    
    # wykorzystujemy tu notacje JSON
    
    slownik2 =	{
      "wzrost": 190,
      "kolor": "brunet",
      "hobby": "szachy"
    }
    
    print(slownik2,len(slownik2))  # {'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3
    
    # mozna też uzyć funkcji dict()
    
    slownik3 = dict(wzrost=190, kolor="brunet", hobby="szachy")
    
    print(slownik3,len(slownik3)) # {'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3
    
    # klucze
    
    # zwracamy liste kluczy
    
    print(slownik3.keys()) # dict_keys(['wzrost', 'kolor', 'hobby'])
          
    # sprawdzamy , czy dany klucz istnieje
    
    # wykorzystujemy operator zawierania in
    
    print('Czy klucz wzrost istnieje w slowniku slownik3 : ','wzrost' in slownik3)
    print('Czy klucz miara istnieje w slowniku slownik3 : ','miara' in slownik3)
    
    # lub negacje operatora in
    
    print('Czy klucz wzrost nie istnieje w slowniku slownik3 : ','wzrost'not in slownik3)
    print('Czy klucz miara nie istnieje w slowniku slownik3 : ','miara' not in slownik3)
    
    # przedsmak wykorzytując pętlę for
    
    for klucz in slownik3.keys():
      print('Slownik slownik3 : ',klucz, '=', slownik3[klucz])
    
    # wartosci
    
    # zwracamy liste wartosci 
    
    print(slownik3.values()) # dict_values([190, 'brunet', 'szachy'])
    
    # klucze/wartosci
    
    # zwracamy listę kluczy-wartosci
    
    print(slownik3.items()) # dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy')])
    
    
    
    # dodanie lub aktualizacja pary klucz-wartosc
    
    slownik3.update({'przyjaciel': False})
    
    
    print(slownik3.items()) # dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', False)])
    
    slownik3.update({'przyjaciel': True}) 
    
    print(slownik3.items()) # dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', True)])
    
    {'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3
    {'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3
    dict_keys(['wzrost', 'kolor', 'hobby'])
    Czy klucz wzrost istnieje w slowniku slownik3 :  True
    Czy klucz miara istnieje w slowniku slownik3 :  False
    Czy klucz wzrost nie istnieje w slowniku slownik3 :  False
    Czy klucz miara nie istnieje w slowniku slownik3 :  True
    Slownik slownik3 :  wzrost = 190
    Slownik slownik3 :  kolor = brunet
    Slownik slownik3 :  hobby = szachy
    dict_values([190, 'brunet', 'szachy'])
    dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy')])
    dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', False)])
    dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', True)])
    

    Konwersja typów dla słowników

    In [13]:
    lista1 = [1,2,3,4] 
    lista2 = ['a','b','c','d'] 
    
    # jak z dwoch list stworzyć słownik
    
    
    # Funkcja zip() tworzy listę krotek z podanych elementów, potem nalezy tę listę skonwertować na słownik
    
    lista12=list(zip(lista1,lista2)) 
    slownik12=dict(zip(lista1,lista2)) 
    
    print("lista12 :",lista12)
    print("slownik12 :",slownik12)
    
    lista12 : [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
    slownik12 : {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
    

    Zbiory {sets}

    In [14]:
    #Deklaracja pustego zbioru, konwertowalnego na typ logiczny jako fałsz
    
    zbior1 = set()
    
    print('Zawartość zbior1 : ',zbior1,'',type(zbior1),bool(zbior1))
    
    # definicja zbioru trzech elementów, konwertowalnego na typ logiczny jako prawda
    zbior2=set(['Agnieszka','Magda','Izabella'])
        
        
    print('Zawartość zbior2 : ',zbior2,'',type(zbior2),bool(zbior2))
    
    # elementy zbioru są unikalnie, nie mogą się powtarzać
    zbior3=set(['Agnieszka','Magda','Izabella','Magda'])
    
        
    print('Zawartość zbior3 : ',zbior3,'',type(zbior3))
    
    # jesli taki element istnieje to nie zostanie dodany do zbioru
    zbior3.add('Agnieszka')
    
    print('Zawartość zbior3 po dodaniu istniejacego elementu: ',zbior3,'',type(zbior3))
    
    
    
    zbiora=set([2,4,8,16])
    zbiorb=set([2,4,6,8])
    print ('\nMamy dwa zbiory: zbiora i zbiorb .')
    print('zbiora : ',zbiora, ' zbiorb : ',zbiorb)
    
    
    # podstawowe operacje na zbiorach
    
    # suma zbiorów: elementy ktore sa w  pierwszym lub drugim zbiorze
    print('\nSuma zbiorów: \n')
    
    print('zbiora | zbiorb : ',zbiora | zbiorb) 
    
    # alternatywnie
    print('zbiora.union(zbiorb) : ',zbiora.union(zbiorb)) 
    
    print('\nRóżnica zbiorów: \n')
    # roznica zbiorow: tylko te elementy ktore sa w  pierwszym zbiorze z nie ma ich w drugim
    print('zbiora - zbiorb : ',zbiora - zbiorb)  
    
    #alternatywnie
    
    print('zbiora.difference(zbiorb) : ',zbiora.difference(zbiorb))  
    
    print('\nIloczyn zbiorów: \n')
    
    # iloczyn zbiorow: elementy ktore sa w pierwszym i drugim zbiorze (czesc wspolna) 
    
    print('zbiora & zbiorb : ',zbiora & zbiorb)                             
    
    #alternatywnie
    
    print('zbiora.intersection(zbiorb)  : ',zbiora.intersection(zbiorb) )   
    
    
    print('\nRóżnica symetryczna zbiorów: \n')
    # roznica symetryczna : elementy ktore sa w obu zbiorach , ale bez ich czesci wspolnej
    
    print('zbiora ^ zbiorb : ',zbiora ^zbiorb)                
    
    # alternatywnie
    
    print('zbiora.symmetric_difference(zbiorb) : ',zbiora.symmetric_difference(zbiorb) ) 
    
    # dodanie elementu do zbioru
    print('\nDodanie elementu zbioru :')
    zbiora.add(7)
    
    print('zbiora : ',zbiora)
    
    # usuniecie elementu ze zbioru
    print('\nUsuniecie elementu zbioru:')
    zbiora.discard(7)
    print('zbiora : ',zbiora)
    
    
    # zawieranie się zbiorów
    
    print('\nZawieranie sie zbiorow: ')
    
    zbior1a = set([1,4,8])
    zbior1b = set([1,2,4,6,8])
    
    print('\nzbior1a : ',zbior1a, ' zbior1b : ',zbior1b)
    
    
    # podzbiory
    
    print('\nPodzbiory: ')
    
    print('czy zbiór zbior1a jest podzbiorem zbioru zbior1b: ',zbior1a.issubset(zbior1b))
    print('czy zbiór zbior1b jest podzbiorem zbioru zbior1a: ',zbior1b.issubset(zbior1a))
    print('czy zbiór zbior1b jest podzbiorem zbioru zbior1b: ',zbior1b.issubset(zbior1b))
    
    
    
    
    # nadzbiory
    
    print('\nNadzbiory: ')
    
    print('czy zbiór zbior1a jest nadzbiorem zbioru zbior1b: ',zbior1a.issuperset(zbior1b))
    print('czy zbiór zbior1b jest nadzbiorem zbioru zbior1a: ',zbior1b.issuperset(zbior1a))
    print('czy zbiór zbior1b jest nadzbiorem zbioru zbior1b: ',zbior1b.issuperset(zbior1b))
    
    
    
    # alternatywnie
    print('\nPodzbiory/nadzbiory alternatywna notacja: ')
    print('czy zbiór zbior1a jest podzbiorem zbioru zbior1b: ',zbior1a<=zbior1b)
    print('czy zbiór zbior1a jest nadzbiorem zbioru zbior1b: ',zbior1a>=zbior1b)
    print('czy zbiór zbior1a jest nadzbiorem zbioru zbior1a: ',zbior1a==zbior1b)
    
    Zawartość zbior1 :  set()  <class 'set'> False
    Zawartość zbior2 :  {'Magda', 'Agnieszka', 'Izabella'}  <class 'set'> True
    Zawartość zbior3 :  {'Magda', 'Agnieszka', 'Izabella'}  <class 'set'>
    Zawartość zbior3 po dodaniu istniejacego elementu:  {'Magda', 'Agnieszka', 'Izabella'}  <class 'set'>
    
    Mamy dwa zbiory: zbiora i zbiorb .
    zbiora :  {8, 16, 2, 4}  zbiorb :  {8, 2, 4, 6}
    
    Suma zbiorów: 
    
    zbiora | zbiorb :  {2, 4, 6, 8, 16}
    zbiora.union(zbiorb) :  {2, 4, 6, 8, 16}
    
    Różnica zbiorów: 
    
    zbiora - zbiorb :  {16}
    zbiora.difference(zbiorb) :  {16}
    
    Iloczyn zbiorów: 
    
    zbiora & zbiorb :  {8, 2, 4}
    zbiora.intersection(zbiorb)  :  {8, 2, 4}
    
    Różnica symetryczna zbiorów: 
    
    zbiora ^ zbiorb :  {16, 6}
    zbiora.symmetric_difference(zbiorb) :  {16, 6}
    
    Dodanie elementu zbioru :
    zbiora :  {2, 4, 7, 8, 16}
    
    Usuniecie elementu zbioru:
    zbiora :  {2, 4, 8, 16}
    
    Zawieranie sie zbiorow: 
    
    zbior1a :  {8, 1, 4}  zbior1b :  {1, 2, 4, 6, 8}
    
    Podzbiory: 
    czy zbiór zbior1a jest podzbiorem zbioru zbior1b:  True
    czy zbiór zbior1b jest podzbiorem zbioru zbior1a:  False
    czy zbiór zbior1b jest podzbiorem zbioru zbior1b:  True
    
    Nadzbiory: 
    czy zbiór zbior1a jest nadzbiorem zbioru zbior1b:  False
    czy zbiór zbior1b jest nadzbiorem zbioru zbior1a:  True
    czy zbiór zbior1b jest nadzbiorem zbioru zbior1b:  True
    
    Podzbiory/nadzbiory alternatywna notacja: 
    czy zbiór zbior1a jest podzbiorem zbioru zbior1b:  True
    czy zbiór zbior1a jest nadzbiorem zbioru zbior1b:  False
    czy zbiór zbior1a jest nadzbiorem zbioru zbior1a:  False
    
    In [15]:
    # Istnieją też zbiory niezmienialne frozenset
    
    zbiorniezmienialny1a =frozenset([1,2,3,4,5,6,7,8])
    print('Zbiór niezmienialny zbiorniezmienialny1a : ',zbiorniezmienialny1a, type(zbiorniezmienialny1a))
    
    # wykonanie tej instrukcji konczy się błedem
    
    zbiorniezmienialny1a.add(9) #AttributeError: 'frozenset' object has no attribute 'add'
    
    # wykonanie tej instrukcji konczy się błedem
    zbiorniezmienialny1a.discard(2) #AttributeError: 'frozenset' object has no attribute 'discard'
    
    Zbiór niezmienialny zbiorniezmienialny1a :  frozenset({1, 2, 3, 4, 5, 6, 7, 8}) <class 'frozenset'>
    
    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    <ipython-input-15-baaf14606d8a> in <module>()
          6 # wykonanie tej instrukcji konczy się błedem
          7 
    ----> 8 zbiorniezmienialny1a.add(9) #AttributeError: 'frozenset' object has no attribute 'add'
          9 
         10 # wykonanie tej instrukcji konczy się błedem
    
    AttributeError: 'frozenset' object has no attribute 'add'

    Konwersja typów dla zbiorów

    In [16]:
    # konwersja z listy do zbioru zmienialnego i niezmienialnego 
    
    listanapedow1=["C:\\","D:\\","E:\\","C:\\"]
    zbiornapedow1=set(listanapedow1)
    zbiornapedow2=frozenset(listanapedow1)
    print('Zbiór zbiornapedow1 : ',zbiornapedow1, type(zbiornapedow1))
    print('Zbiór zbiornapedow2 : ',zbiornapedow2, type(zbiornapedow2))
    
    # konwersja każdej litery na element zbioru
    
    zbiorn1=set('Dorotka')
    
    
    # konwersja całego napisu na element zbioru
    
    zbiorn2=set(['Dorotka'])
    
    print('Zbiór :',zbiorn1,type(zbiorn1),' o długości : ',len(zbiorn1))
    print('Zbiór :',zbiorn2,type(zbiorn2),' o długości : ',len(zbiorn2))
    
    Zbiór zbiornapedow1 :  {'E:\\', 'C:\\', 'D:\\'} <class 'set'>
    Zbiór zbiornapedow2 :  frozenset({'E:\\', 'C:\\', 'D:\\'}) <class 'frozenset'>
    Zbiór : {'o', 'a', 'D', 'k', 'r', 't'} <class 'set'>  o długości :  6
    Zbiór : {'Dorotka'} <class 'set'>  o długości :  1
    
    Categories: migawka, Python

    Dodaj komentarz

    Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *