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