pn/predavanja/06 Mnozice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c2493e3",
   "metadata": {},
   "source": [
    "Množice\n",
    "-------\n",
    "\n",
    "Množice so podobne seznamom, a s to razliko, da lahko vsebujejo vsak element samo enkrat. \n",
    "\n",
    "Po drugi strani (in ne le po drugi strani, tudi tehnično) pa so podobne slovarjem. Vsebujejo lahko le elemente, ki so nespremenljivi, poleg tega pa lahko zelo hitro ugotovimo, ali množica vsebuje določen element ali ne, na podoben način kot pri slovarjih hitro ugotovimo, ali vsebujejo določen ključ ali ne.\n",
    "\n",
    "Množice so podobne slovarjem tudi zato, ker nimajo vrstnega reda. In to še v veliko večji meri kot slovarji: elementi slovarja so urejeni po vrstnem redu dodajanja (od Pythona 3.6 naprej; podobne strukture v drugih jezikih pa navadno niti to), elementi množice pa ne, poleg tega pa se lahko njihov vrstni red, kakor ga pokaže zanka `for`, popolnoma premeša, ko iz nje dodamo ali odvzamemo kak element. \n",
    "\n",
    "Končno, množice so podobne slovarjem po tem, da jih zapišemo z zavitimi oklepaji, tako kot smo vajeni pri matematiki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8205a7ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "danasnji_klici = {\"Ana\", \"Cilka\", \"Eva\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c696a118",
   "metadata": {},
   "source": [
    "Tako lahko sestavimo le neprazno množico. Če napišemo le oklepaj in zaklepaj, `{}`, pa dobimo slovar. (Čemu so se odločili, naj bo to slovar, ne množica? Slovar je bil prej, množice je Python dobil kasneje. Zato. Poleg tega pa slovarje potrebujemo res velikokrat, množice pa precej redkeje.) Če hočemo narediti prazno množico, rečemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "16f290c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "prazna = set()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "178aa968",
   "metadata": {},
   "source": [
    "\"Funkcija\" `set` je malo podobna \"funkciji\" `int`: damo ji lahko različne argumente, pa jih bo spremenila v množico. Damo ji lahko, recimo, seznam, pa bomo dobili množico z vsemi elementi, ki se pojavijo v njem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bbf8fdfe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f1ce2040",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 6, 42}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([6, 42, 1, 3, 1, 1, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60239fbb",
   "metadata": {},
   "source": [
    "Poleg seznamov lahko množicam podtaknemo karkoli, prek česar bi lahko šli z zanko `for`, recimo niz ali slovar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "70b14ffb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B', 'a', 'e', 'i', 'j', 'm', 'n'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = set(\"Benjamin\")\n",
    "\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2af10a",
   "metadata": {},
   "source": [
    "Vprašamo se lahko, ali množica vsebuje določen element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6d9aa45d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"e\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2485c332",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"u\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ad982465",
   "metadata": {},
   "outputs": [],
   "source": [
    "s.add(\"u\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "58906458",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"u\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "03763cf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B', 'a', 'e', 'i', 'j', 'm', 'n', 'u'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.add(\"a\")\n",
    "s.add(\"a\")\n",
    "s.add(\"a\")\n",
    "\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce4f2ddc",
   "metadata": {},
   "source": [
    "Na koncu smo poskušali v množico dodati element, ki ga že vsebuje. Python se ne pritoži, vendar tudi ne stori ničesar: množica vsak element vsebuje le enkrat.\n",
    "\n",
    "Če imamo dve množici, lahko izračunamo njuno unijo, presek, razliko (elementi, ki se pojavijo v prvi, ne pa tudi v drugi množici) in simetrično razliko (elementi, ki se pojavijo v eni množici in v drugi) ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f600ab97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = {1, 2, 3}\n",
    "v = {3, 4, 5}\n",
    "u | v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6259422e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u & v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9abb7b50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u - v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b66da9fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 5}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u ^ v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85c3908b",
   "metadata": {},
   "source": [
    "Tako kot lahko pri številih uporabimo `+=` za prištevanje (in namesto `x = x + a` pišemo `x += a`), in, podobno, odštejemo, primnožimo in razdelimo z `-=`, `*=` in `/=`, lahko tudi priunijamo, odsekamo ali odštejemo množico z `&=`, `|=` in `-=`. Tako je, na primer `u &= v` isto kot `u = u & v`.\n",
    "\n",
    "Preverimo lahko tudi, ali je neka množica podmnožica (ali nadmnožica druge). To najpreprosteje storimo kar z operatorji za primerjanje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8c3bfa96",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = {1, 2, 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d82b2365",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "437d754b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3, 4} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7838dc3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ad0f851d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} < u"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0037b397",
   "metadata": {},
   "source": [
    "`{1, 2, 3}`, je podmnožica `u`-ja, ni pa njegove *prava podmnožica*, saj vsebuje kar cel `u`.\n",
    "\n",
    "Z množicami je mogoče početi še marsikaj zanimivega - vendar bodi dovolj. Več primerov pa si bomo ogledali sproti."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}