{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Indeksowanie" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Napis s : Witamy na kursie Pythona.\n", "\n", "Indeksowanie dodatnie:\n", "\n", "Pierwszy element napisu s1 : W\n", "Drugi element napisu s1 : i\n", "Trzeci element napisu s1 : t\n", "Ostatni element napisu s1 : .\n", "\n", "Indeksowanie ujemne:\n", "\n", "Ostatni element napisu s1 : .\n", "Przedostatni element napisu s1 : a\n", "Pierwszy element napisu s1 : W\n" ] } ], "source": [ "# deklarujemy zmienną s1 typu napis \n", "\n", "s1=\"Witamy na kursie Pythona.\"\n", "print('Napis s : ',s1)\n", "\n", "#pierwszy element napisu oznaczamy cyfra 0 []\n", "\n", "print (\"\\nIndeksowanie dodatnie:\\n\")\n", "\n", "print('Pierwszy element napisu s1 : ',s1[0])\n", "\n", "# drugi element [1]\n", "\n", "print('Drugi element napisu s1 : ',s1[1])\n", "\n", "# trzeci element [2]\n", "\n", "print('Trzeci element napisu s1 : ',s1[2])\n", "\n", "\n", "# ostatni element napisu [dlugosc -1]\n", "\n", "print('Ostatni element napisu s1 : ',s1[len(s1)-1])\n", "\n", "print (\"\\nIndeksowanie ujemne:\\n\")\n", "\n", "# mozna tez wykorzystac indeksy ujemne\n", "\n", "\n", "# ostatni element [-1]\n", "\n", "print('Ostatni element napisu s1 : ',s1[-1])\n", "\n", "# przedostatni element [-2]\n", "\n", "print('Przedostatni element napisu s1 : ',s1[-2])\n", "\n", "# pierwszy element [-dlugosc]\n", "\n", "print('Pierwszy element napisu s1 : ',s1[-len(s1)])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tworzenie podciagów" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Oryginalny napis Witamy na kursie Pythona. o długości 25\n", "Drugi element o indeksie [1] : i\n", "Wszystkie elementy napisu s1 : Witamy na kursie Pythona.\n", "Co drugi element napisu s1 : Wtm akri yhn.\n", "Napis s1 w odwrotnej kolejności : .anohtyP eisruk an ymatiW\n", "Co drugi element napisu s1 w odwrotnej kolejnosci : .nhy irka mtW\n" ] } ], "source": [ "# tworzenie podciagow (slice)\n", "\n", "s1=\"Witamy na kursie Pythona.\"\n", "print('Oryginalny napis ',s1, ' o długości ',len(s1))\n", "\n", "# tworzymy podciag zaczynajacy sie od indeksu [1] do ponizej indeksu [2]\n", "\n", "print ('Drugi element o indeksie [1] : ',s1[1:2]) # wyswietlamy tylko element drugi - indeks [1]\n", "\n", "# ogolna postac [a:b:c] \n", "# a oznacza indeks elementu startowego, \n", "# b oznacza gorny indeks elementu, ktory nas nie interesuje\n", "# c oznaccza roznice miedzy kolejnymi indeksami\n", "\n", "# domyslnie a =0, b =len(napis), c = 1\n", "\n", "# wyswietlenie wzystkich elementow napisu\n", "\n", "print('Wszystkie elementy napisu s1 : ',s1[::])\n", "\n", "\n", "# wyswietlanie co drugiego elementu napisu\n", "\n", "print('Co drugi element napisu s1 : ',s1[::2])\n", "\n", "# krok zmiany moze byc tez ujemny\n", "\n", "print('Napis s1 w odwrotnej kolejności : ',s1[::-1])\n", "\n", "# co drugi element w odwrotnej kolejnosci\n", "\n", "print('Co drugi element napisu s1 w odwrotnej kolejnosci : ',s1[::-2])\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Listy [lists]\n", "\n", "#### LIsty sa obiektami sekwencyjnymi zmienialnymi (mutable)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Lista lista1 : [1, 2, 'Ala', 4] \n", "Lista lista2 : [] False\n", "[1, 2, 'Ala', 4] 2\n", "4\n", "Lista lista1 : [1, 2, 'Ala', 'ma']\n", "Lista lista1 : [1, 2, 'Ala', 'ma', 'kota']\n", "Lista lista11 : kota Lista lista1 : [1, 2, 'Ala', 'ma']\n", "Lista lista1rev : ['ma', 'Ala', 2, 1]\n", "Lista lista12 : None o liczbie elementow : None\n", "Lista lista1 : [1, 2, ['Basia', 'ma', 'psa'], 'Ala', 'ma'] o liczbe elementow : 5\n", "Lista lista3 : [1, 2, ['Basia', 'ma', 'psa'], 'Ala', 'ma', 1, 2, ['Basia', 'ma', 'psa'], 'Ala', 'ma'] o liczbie elementow : 10\n", "Lista lista4 : [1, 2, ['Basia', 'ma', 'psa'], 'Ala', 1, 2, ['Basia', 'ma', 'psa'], 'Ala'] o liczbie elementow : 8\n", "Lista lista5 : [1, 2, ['Basia', 'ma', 'psa'], 1, 2, ['Basia', 'ma', 'psa']] o liczbie elementow : 6\n" ] } ], "source": [ "# listy tworzymy za pomoca nawiasów kwadratowych []\n", "\n", "lista1=[1,2,'Ala',4]\n", "print('Lista lista1 : ',lista1,type(lista1))\n", "\n", "# elementy listy nie musze byc tego samego typu\n", "\n", "# utworzmy pusta liste, warto pamietac ze konwersja takiej listy na typ logiczny zwraca falsz\n", "\n", "lista2=[]\n", "\n", "print('Lista lista2 : ',lista2,type(lista2),bool(lista2))\n", "\n", "# indeksowanie elementow analogiczne jak dla napisow\n", "\n", "print(lista1, lista1[1]) # \"[1, 2, 'Ala', 4]\"\n", "print(lista1[-1]) # Wyswietla ostatni element listy\n", "lista1[3] = 'ma' # Zmiana elementu o indeksie [3] \n", "print('Lista lista1 : ',lista1) # wyswietla \"[1, 2, 'Ala', 'ma']\"\n", "\n", "# dedykowane dla list metody\n", "\n", "lista1.append('kota') # Dodajemy element listy na jej koncu\n", "print('Lista lista1 : ',lista1) # \"[1, 2, 'Ala', 'ma', 'kota']\"\n", "\n", "\n", "lista11 = lista1.pop() # Odczytanie ostatniego elementu listy z jednoczesnym usunieciem\n", "print('Lista lista11 : ',lista11,'Lista lista1 : ', lista1) # kota [1, 2, 'Ala', 'ma']\n", "\n", "# lista w odwrotnej kolejnosci\n", "\n", "lista1rev=lista1[::-1]\n", "print('Lista lista1rev : ',lista1rev) # kota [1, 2, 'Ala', 'ma']\n", "\n", "# dodanie nowego elementu listy w pozycji o indeksie 2, w szczegolnosci moze byc to kolejna lista\n", "\n", "lista12 = lista1.insert(2,['Basia','ma','psa'])\n", "print('Lista lista12 : ',lista12,' o liczbie elementow : ', lista12)\n", "\n", "\n", "# liczba elementow listy\n", "print('Lista lista1 : ',lista1, 'o liczbe elementow : ',len(lista1))\n", "\n", "# dodawanie list\n", "\n", "lista3 = lista1 +lista1\n", "print('Lista lista3 : ',lista3, 'o liczbie elementow : ',len(lista3))\n", "\n", "# mnozenie listy przez wartosc z prawej strony\n", "\n", "lista4=lista3[:4:1]*2;\n", "print('Lista lista4 : ',lista4, ' o liczbie elementow : ',len(lista4))\n", "\n", "# mnozenie listy przez wartosc z lewej strony\n", "\n", "lista5=2*lista3[:3:1];\n", "print('Lista lista5 : ',lista5,' o liczbie elementow : ',len(lista5))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Konwersja typow dla list" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "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\n", "Napis s2 : Ala ma kota, a Basia ma psa. o dlugosci : 28\n", "Sekwencja r1 : range(0, 50) liczba elementow : 50\n", "Sekwencja r2 : range(-20, 20) liczba elementow : 40\n", "Sekwencja r3 : range(-20, 20, 2) liczba elementow : 20\n", "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] \n", "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] \n", "Lista lr3 : [-20, -18, -16, -14, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18] \n" ] } ], "source": [ "# konwersja na typ listy -> list(obiekt)\n", "\n", "# zamiana napisu na liste, kazdy z elementow napisu jest zamieniony na element listy\n", "\n", "s1='Ala ma kota, a Basia ma psa.';\n", "l1=list(s1)\n", "print('Lista l1 : ',l1,' o liczbie elementow: ',len(l1))\n", "\n", "# konwersja z listy na napis, \n", "\n", "s2=''.join(l1)\n", "print('Napis s2 : ',s2, ' o dlugosci : ',len(s2))\n", "\n", "# type range, bedziemy z niego intensywnie korzystac przy petlach, domyslny krok 1.\n", "\n", "r1=range(50) # generujemy liczby od zera do najwiekszej mniejszej niz 50\n", "print('Sekwencja r1 : ',r1, type(r1),' liczba elementow : ',len(r1)) # \n", "\n", "r2=range(-20,20) # generujemy liczby od -20 do najwiekszej mniejszej niz 20\n", "print('Sekwencja r2 : ',r2, type(r2),' liczba elementow : ',len(r2)) # \n", "\n", "r3=range(-20,20,2) # generujemy liczby od -20 do najwiekszej mniejszej niz 20 co krok rowny 2\n", "print('Sekwencja r3 : ',r3, type(r3),' liczba elementow : ',len(r3)) # \n", "\n", "\n", "# zamiana na liste\n", "\n", "lr1=list(r1)\n", "print('Lista lr1 : ',lr1, type(lr1)) # \n", "lr2=list(r2)\n", "print('Lista lr2 : ',lr2, type(lr2)) # \n", "lr3=list(r3)\n", "print('Lista lr3 : ',lr3, type(lr3)) # \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Krotki (tuples)\n", "\n", "#### Krotki sa elementami sekwencyjnymi niezmienialnymi (immutable)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 3, 5, 'Pies') \n", "(1, 2, 3, 4, 'Ala', 'ma', 'kota') \n", "() False\n", "1 \n", "(1,) \n" ] } ], "source": [ "# krotki tworzymy za pomoca nawiasów zwyklych ()\n", "\n", "k1= 1,3,5,'Pies'\n", "print(k1,type(k1))\n", "\n", "# W szczegolnosci mozemy tworzyc krotki bez wykorzystania ()\n", "\n", "k2 = 1,2,3,4,'Ala','ma','kota'\n", "print(k2,type(k2))\n", "\n", "# pusta krotka, konwertowalna na typ logiczny jako falsz\n", "\n", "k3=()\n", "\n", "print(k3,type(k3),bool(k3))\n", "\n", "# budowa krotki z jednym elementem\n", "\n", "k4a=(1)\n", "print(k4a,type(k4a)) # 1 \n", "\n", "# w takim przypadku, nalezy postawic znak , po wartosci pierwszego/ostatniego elementu\n", "\n", "k4b=(1,)\n", "print(k4b,type(k4b)) # (1,) \n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Zawartosc krotki k5 : ('Ala', 'ma', 'kota', 3.14, 12, 2.0)\n", "Pierwszy element krotki k5: Ala\n", "Ostatni element: 2.0\n", "krotka1[0]: Poznan\n", "krotka2[1:5]: (2, 3, 4, 5)\n" ] } ], "source": [ "# dostep do elementow krotki analogicznie jak do elementow listy\n", "\n", "k5=('Ala','ma','kota',3.14,12,2.0)\n", "print('Zawartosc krotki k5 : ',k5)\n", "print('Pierwszy element krotki k5: ',k5[0])\n", "\n", "print('Ostatni element: ',k5[-1])\n", "\n", "# dostep do elementow krotki \n", "\n", "krotka1 = ('Poznan', 'Warszawa', 1995, 2018)\n", "krotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)\n", "\n", "print (\"krotka1[0]: \", krotka1[0])\n", "print (\"krotka2[1:5]: \", krotka2[1:5])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mkrotka1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Poznan'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Warszawa'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1995\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2018\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mkrotka1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m\u001b[1;36m1999\u001b[0m \u001b[1;31m# TypeError: 'tuple' object does not support item assignment\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;31m# krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "# modyfikacja elementu krotki\n", "\n", "krotka1 = ('Poznan', 'Warszawa', 1995, 2018)\n", "\n", "krotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment\n", "\n", "# krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Zawartosc krotka1 : ('Poznan', 'Warszawa', 1995, 2018) o dlugosci : 4\n", "Zawartosc krotka2 : (1, 2, 3, 4, 5, 6, 7, 8) o dlugosci : 8\n", "Zawartosc krotka3 : ('Poznan', 'Warszawa', 1995, 2018, 1, 2, 3, 4, 5, 6, 7, 8) o dlugosci : 12\n" ] } ], "source": [ "krotka1 = ('Poznan', 'Warszawa', 1995, 2018)\n", "krotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)\n", "\n", "krotka3=krotka1+krotka2\n", "print('Zawartosc krotka1 : ',krotka1,' o dlugosci :',len(krotka1))\n", "print('Zawartosc krotka2 : ',krotka2,' o dlugosci :',len(krotka2))\n", "print('Zawartosc krotka3 : ',krotka3,' o dlugosci :',len(krotka3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dodatkowe operacje na krotkach" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Krotka osoby : ('Alicja', 'Magda', 'Izabella', 'Agnieszka', 'Jadwiga')\n", "Krotka osoby po sortowaniu : ('Agnieszka', 'Alicja', 'Izabella', 'Jadwiga', 'Magda')\n" ] } ], "source": [ "# Sortowanie\n", "\n", "# kwotka nieposortowana\n", "\n", "osoby = ('Alicja','Magda','Izabella','Agnieszka','Jadwiga')\n", "print('Krotka osoby :', osoby)\n", "\n", "# sortowanie krotki osoby\n", "\n", "osoby = tuple(sorted(osoby))\n", "\n", "print('Krotka osoby po sortowaniu :', osoby)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Konwersja typow dla krotek" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Krotkax : (1, 5, 3, 6) liczba elementow : 4\n", "Krotkax po sortowaniu: (1, 3, 5, 6) liczba elementow : 4\n" ] } ], "source": [ "\n", "listax = [1,5,3,6]\n", "\n", "# konwersja na krotke za pomoaca funkcji tuple()\n", "\n", "krotkax = tuple(listax)\n", "print('Krotkax : ',krotkax,type(krotkax),'liczba elementow : ',len(krotkax))\n", "\n", "# sortowanie \n", "krotkax = tuple(sorted(listax))\n", "print('Krotkax po sortowaniu: ',krotkax,type(krotkax),'liczba elementow : ',len(krotkax))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Slowniki {dictionaries}" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{} False\n", "{'wzrost': 187, 'kolor': 'blond'} 2\n", "{'wzrost': 190, 'kolor': 'blond'} 2\n", "{'kolor': 'blond'} 1\n", "{'kolor': 'blond', 'wzrost': 190} 2\n", "{} 0\n" ] } ], "source": [ "# słowniki przechowuja zestawy par klucz-wartość\n", "\n", "#tworzymy pusty słownik, rzutowany na typ logiczny daje wartość fałszu\n", "\n", "slownik1={}\n", "\n", "print(slownik1,type(slownik1),bool(slownik1)) # {} False\n", "\n", "# dodajemy pierwsza parę do pustego słownika\n", "\n", "slownik1['wzrost']=187\n", "\n", "# dodajemy druga pare\n", "\n", "slownik1['kolor']='blond'\n", "\n", "print(slownik1,len(slownik1)) # {'wzrost': 187, 'kolor': 'blond'} 2\n", "\n", "# klucz jest unikalny w ramach slownika\n", "\n", "# zmiana wartosci dla klucza, takie podstawienie niszczy poprzednia wartość\n", "slownik1['wzrost']=190\n", "\n", "print(slownik1,len(slownik1)) # {'wzrost': 190, 'kolor': 'blond'} 2\n", "\n", "# usuniecie pary klucz-wartosc\n", "\n", "del slownik1['wzrost']\n", "\n", "print(slownik1,len(slownik1)) # {'kolor': 'blond'} 1\n", "\n", "\n", "# dodanie po raz kolejny pary {'wzrost':1}\n", "slownik1['wzrost']=190\n", "\n", "# zauważmy zmianę kolejności kluczy\n", "print(slownik1,len(slownik1)) # {'kolor': 'blond', 'wzrost': 190} 2\n", "\n", "# wyczyszczenie zawartości słownika\n", "\n", "slownik1.clear()\n", "\n", "print(slownik1,len(slownik1)) # {} 0\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'slownik1' is not defined", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mslownik1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mslownik1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mslownik1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# NameError: name 'slownik1' is not defined\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mNameError\u001b[0m: name 'slownik1' is not defined" ] } ], "source": [ "#usunięcie obiektu \n", "\n", "del slownik1\n", "\n", "print(slownik1,len(slownik1)) # NameError: name 'slownik1' is not defined" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3\n", "{'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3\n", "dict_keys(['wzrost', 'kolor', 'hobby'])\n", "Czy klucz wzrost istnieje w slowniku slownik3 : True\n", "Czy klucz miara istnieje w slowniku slownik3 : False\n", "Czy klucz wzrost nie istnieje w slowniku slownik3 : False\n", "Czy klucz miara nie istnieje w slowniku slownik3 : True\n", "Slownik slownik3 : wzrost = 190\n", "Slownik slownik3 : kolor = brunet\n", "Slownik slownik3 : hobby = szachy\n", "dict_values([190, 'brunet', 'szachy'])\n", "dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy')])\n", "dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', False)])\n", "dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', True)])\n" ] } ], "source": [ "# tworzymy slownik z trzema parami klucz-wartosc\n", "\n", "# wykorzystujemy tu notacje JSON\n", "\n", "slownik2 =\t{\n", " \"wzrost\": 190,\n", " \"kolor\": \"brunet\",\n", " \"hobby\": \"szachy\"\n", "}\n", "\n", "print(slownik2,len(slownik2)) # {'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3\n", "\n", "# mozna też uzyć funkcji dict()\n", "\n", "slownik3 = dict(wzrost=190, kolor=\"brunet\", hobby=\"szachy\")\n", "\n", "print(slownik3,len(slownik3)) # {'wzrost': 190, 'kolor': 'brunet', 'hobby': 'szachy'} 3\n", "\n", "# klucze\n", "\n", "# zwracamy liste kluczy\n", "\n", "print(slownik3.keys()) # dict_keys(['wzrost', 'kolor', 'hobby'])\n", " \n", "# sprawdzamy , czy dany klucz istnieje\n", "\n", "# wykorzystujemy operator zawierania in\n", "\n", "print('Czy klucz wzrost istnieje w slowniku slownik3 : ','wzrost' in slownik3)\n", "print('Czy klucz miara istnieje w slowniku slownik3 : ','miara' in slownik3)\n", "\n", "# lub negacje operatora in\n", "\n", "print('Czy klucz wzrost nie istnieje w slowniku slownik3 : ','wzrost'not in slownik3)\n", "print('Czy klucz miara nie istnieje w slowniku slownik3 : ','miara' not in slownik3)\n", "\n", "# przedsmak wykorzytując pętlę for\n", "\n", "for klucz in slownik3.keys():\n", " print('Slownik slownik3 : ',klucz, '=', slownik3[klucz])\n", "\n", "# wartosci\n", "\n", "# zwracamy liste wartosci \n", "\n", "print(slownik3.values()) # dict_values([190, 'brunet', 'szachy'])\n", "\n", "# klucze/wartosci\n", "\n", "# zwracamy listę kluczy-wartosci\n", "\n", "print(slownik3.items()) # dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy')])\n", "\n", "\n", "\n", "# dodanie lub aktualizacja pary klucz-wartosc\n", "\n", "slownik3.update({'przyjaciel': False})\n", "\n", "\n", "print(slownik3.items()) # dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', False)])\n", "\n", "slownik3.update({'przyjaciel': True}) \n", "\n", "print(slownik3.items()) # dict_items([('wzrost', 190), ('kolor', 'brunet'), ('hobby', 'szachy'), ('przyjaciel', True)])\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Konwersja typów dla słowników" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "lista12 : [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]\n", "slownik12 : {1: 'a', 2: 'b', 3: 'c', 4: 'd'}\n" ] } ], "source": [ "lista1 = [1,2,3,4] \n", "lista2 = ['a','b','c','d'] \n", "\n", "# jak z dwoch list stworzyć słownik\n", "\n", "\n", "# Funkcja zip() tworzy listę krotek z podanych elementów, potem nalezy tę listę skonwertować na słownik\n", "\n", "lista12=list(zip(lista1,lista2)) \n", "slownik12=dict(zip(lista1,lista2)) \n", "\n", "print(\"lista12 :\",lista12)\n", "print(\"slownik12 :\",slownik12)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Zbiory {sets}" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Zawartość zbior1 : set() False\n", "Zawartość zbior2 : {'Magda', 'Agnieszka', 'Izabella'} True\n", "Zawartość zbior3 : {'Magda', 'Agnieszka', 'Izabella'} \n", "Zawartość zbior3 po dodaniu istniejacego elementu: {'Magda', 'Agnieszka', 'Izabella'} \n", "\n", "Mamy dwa zbiory: zbiora i zbiorb .\n", "zbiora : {8, 16, 2, 4} zbiorb : {8, 2, 4, 6}\n", "\n", "Suma zbiorów: \n", "\n", "zbiora | zbiorb : {2, 4, 6, 8, 16}\n", "zbiora.union(zbiorb) : {2, 4, 6, 8, 16}\n", "\n", "Różnica zbiorów: \n", "\n", "zbiora - zbiorb : {16}\n", "zbiora.difference(zbiorb) : {16}\n", "\n", "Iloczyn zbiorów: \n", "\n", "zbiora & zbiorb : {8, 2, 4}\n", "zbiora.intersection(zbiorb) : {8, 2, 4}\n", "\n", "Różnica symetryczna zbiorów: \n", "\n", "zbiora ^ zbiorb : {16, 6}\n", "zbiora.symmetric_difference(zbiorb) : {16, 6}\n", "\n", "Dodanie elementu zbioru :\n", "zbiora : {2, 4, 7, 8, 16}\n", "\n", "Usuniecie elementu zbioru:\n", "zbiora : {2, 4, 8, 16}\n", "\n", "Zawieranie sie zbiorow: \n", "\n", "zbior1a : {8, 1, 4} zbior1b : {1, 2, 4, 6, 8}\n", "\n", "Podzbiory: \n", "czy zbiór zbior1a jest podzbiorem zbioru zbior1b: True\n", "czy zbiór zbior1b jest podzbiorem zbioru zbior1a: False\n", "czy zbiór zbior1b jest podzbiorem zbioru zbior1b: True\n", "\n", "Nadzbiory: \n", "czy zbiór zbior1a jest nadzbiorem zbioru zbior1b: False\n", "czy zbiór zbior1b jest nadzbiorem zbioru zbior1a: True\n", "czy zbiór zbior1b jest nadzbiorem zbioru zbior1b: True\n", "\n", "Podzbiory/nadzbiory alternatywna notacja: \n", "czy zbiór zbior1a jest podzbiorem zbioru zbior1b: True\n", "czy zbiór zbior1a jest nadzbiorem zbioru zbior1b: False\n", "czy zbiór zbior1a jest nadzbiorem zbioru zbior1a: False\n" ] } ], "source": [ "#Deklaracja pustego zbioru, konwertowalnego na typ logiczny jako fałsz\n", "\n", "zbior1 = set()\n", "\n", "print('Zawartość zbior1 : ',zbior1,'',type(zbior1),bool(zbior1))\n", "\n", "# definicja zbioru trzech elementów, konwertowalnego na typ logiczny jako prawda\n", "zbior2=set(['Agnieszka','Magda','Izabella'])\n", " \n", " \n", "print('Zawartość zbior2 : ',zbior2,'',type(zbior2),bool(zbior2))\n", "\n", "# elementy zbioru są unikalnie, nie mogą się powtarzać\n", "zbior3=set(['Agnieszka','Magda','Izabella','Magda'])\n", "\n", " \n", "print('Zawartość zbior3 : ',zbior3,'',type(zbior3))\n", "\n", "# jesli taki element istnieje to nie zostanie dodany do zbioru\n", "zbior3.add('Agnieszka')\n", "\n", "print('Zawartość zbior3 po dodaniu istniejacego elementu: ',zbior3,'',type(zbior3))\n", "\n", "\n", "\n", "zbiora=set([2,4,8,16])\n", "zbiorb=set([2,4,6,8])\n", "print ('\\nMamy dwa zbiory: zbiora i zbiorb .')\n", "print('zbiora : ',zbiora, ' zbiorb : ',zbiorb)\n", "\n", "\n", "# podstawowe operacje na zbiorach\n", "\n", "# suma zbiorów: elementy ktore sa w pierwszym lub drugim zbiorze\n", "print('\\nSuma zbiorów: \\n')\n", "\n", "print('zbiora | zbiorb : ',zbiora | zbiorb) \n", "\n", "# alternatywnie\n", "print('zbiora.union(zbiorb) : ',zbiora.union(zbiorb)) \n", "\n", "print('\\nRóżnica zbiorów: \\n')\n", "# roznica zbiorow: tylko te elementy ktore sa w pierwszym zbiorze z nie ma ich w drugim\n", "print('zbiora - zbiorb : ',zbiora - zbiorb) \n", "\n", "#alternatywnie\n", "\n", "print('zbiora.difference(zbiorb) : ',zbiora.difference(zbiorb)) \n", "\n", "print('\\nIloczyn zbiorów: \\n')\n", "\n", "# iloczyn zbiorow: elementy ktore sa w pierwszym i drugim zbiorze (czesc wspolna) \n", "\n", "print('zbiora & zbiorb : ',zbiora & zbiorb) \n", "\n", "#alternatywnie\n", "\n", "print('zbiora.intersection(zbiorb) : ',zbiora.intersection(zbiorb) ) \n", "\n", "\n", "print('\\nRóżnica symetryczna zbiorów: \\n')\n", "# roznica symetryczna : elementy ktore sa w obu zbiorach , ale bez ich czesci wspolnej\n", "\n", "print('zbiora ^ zbiorb : ',zbiora ^zbiorb) \n", "\n", "# alternatywnie\n", "\n", "print('zbiora.symmetric_difference(zbiorb) : ',zbiora.symmetric_difference(zbiorb) ) \n", "\n", "# dodanie elementu do zbioru\n", "print('\\nDodanie elementu zbioru :')\n", "zbiora.add(7)\n", "\n", "print('zbiora : ',zbiora)\n", "\n", "# usuniecie elementu ze zbioru\n", "print('\\nUsuniecie elementu zbioru:')\n", "zbiora.discard(7)\n", "print('zbiora : ',zbiora)\n", "\n", "\n", "# zawieranie się zbiorów\n", "\n", "print('\\nZawieranie sie zbiorow: ')\n", "\n", "zbior1a = set([1,4,8])\n", "zbior1b = set([1,2,4,6,8])\n", "\n", "print('\\nzbior1a : ',zbior1a, ' zbior1b : ',zbior1b)\n", "\n", "\n", "# podzbiory\n", "\n", "print('\\nPodzbiory: ')\n", "\n", "print('czy zbiór zbior1a jest podzbiorem zbioru zbior1b: ',zbior1a.issubset(zbior1b))\n", "print('czy zbiór zbior1b jest podzbiorem zbioru zbior1a: ',zbior1b.issubset(zbior1a))\n", "print('czy zbiór zbior1b jest podzbiorem zbioru zbior1b: ',zbior1b.issubset(zbior1b))\n", "\n", "\n", "\n", "\n", "# nadzbiory\n", "\n", "print('\\nNadzbiory: ')\n", "\n", "print('czy zbiór zbior1a jest nadzbiorem zbioru zbior1b: ',zbior1a.issuperset(zbior1b))\n", "print('czy zbiór zbior1b jest nadzbiorem zbioru zbior1a: ',zbior1b.issuperset(zbior1a))\n", "print('czy zbiór zbior1b jest nadzbiorem zbioru zbior1b: ',zbior1b.issuperset(zbior1b))\n", "\n", "\n", "\n", "# alternatywnie\n", "print('\\nPodzbiory/nadzbiory alternatywna notacja: ')\n", "print('czy zbiór zbior1a jest podzbiorem zbioru zbior1b: ',zbior1a<=zbior1b)\n", "print('czy zbiór zbior1a jest nadzbiorem zbioru zbior1b: ',zbior1a>=zbior1b)\n", "print('czy zbiór zbior1a jest nadzbiorem zbioru zbior1a: ',zbior1a==zbior1b)\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Zbiór niezmienialny zbiorniezmienialny1a : frozenset({1, 2, 3, 4, 5, 6, 7, 8}) \n" ] }, { "ename": "AttributeError", "evalue": "'frozenset' object has no attribute 'add'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;31m# wykonanie tej instrukcji konczy się błedem\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mzbiorniezmienialny1a\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m9\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#AttributeError: 'frozenset' object has no attribute 'add'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[1;31m# wykonanie tej instrukcji konczy się błedem\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'" ] } ], "source": [ "# Istnieją też zbiory niezmienialne frozenset\n", "\n", "zbiorniezmienialny1a =frozenset([1,2,3,4,5,6,7,8])\n", "print('Zbiór niezmienialny zbiorniezmienialny1a : ',zbiorniezmienialny1a, type(zbiorniezmienialny1a))\n", "\n", "# wykonanie tej instrukcji konczy się błedem\n", "\n", "zbiorniezmienialny1a.add(9) #AttributeError: 'frozenset' object has no attribute 'add'\n", "\n", "# wykonanie tej instrukcji konczy się błedem\n", "zbiorniezmienialny1a.discard(2) #AttributeError: 'frozenset' object has no attribute 'discard'\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Konwersja typów dla zbiorów" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Zbiór zbiornapedow1 : {'E:\\\\', 'C:\\\\', 'D:\\\\'} \n", "Zbiór zbiornapedow2 : frozenset({'E:\\\\', 'C:\\\\', 'D:\\\\'}) \n", "Zbiór : {'o', 'a', 'D', 'k', 'r', 't'} o długości : 6\n", "Zbiór : {'Dorotka'} o długości : 1\n" ] } ], "source": [ "# konwersja z listy do zbioru zmienialnego i niezmienialnego \n", "\n", "listanapedow1=[\"C:\\\\\",\"D:\\\\\",\"E:\\\\\",\"C:\\\\\"]\n", "zbiornapedow1=set(listanapedow1)\n", "zbiornapedow2=frozenset(listanapedow1)\n", "print('Zbiór zbiornapedow1 : ',zbiornapedow1, type(zbiornapedow1))\n", "print('Zbiór zbiornapedow2 : ',zbiornapedow2, type(zbiornapedow2))\n", "\n", "# konwersja każdej litery na element zbioru\n", "\n", "zbiorn1=set('Dorotka')\n", "\n", "\n", "# konwersja całego napisu na element zbioru\n", "\n", "zbiorn2=set(['Dorotka'])\n", "\n", "print('Zbiór :',zbiorn1,type(zbiorn1),' o długości : ',len(zbiorn1))\n", "print('Zbiór :',zbiorn2,type(zbiorn2),' o długości : ',len(zbiorn2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }