{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kynning á Python\n",
    "\n",
    "## Helstu atriði\n",
    "\n",
    "- Breytur\n",
    "- Tög/týpur\n",
    "- Stýrisetningar\n",
    "- Strengir\n",
    "- Föll\n",
    "- Listar\n",
    "\n",
    "\n",
    "Hlekkir til að skoða\n",
    "https://docs.python.org/3/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Breytur\n",
    "\n",
    "Breytur hafa ekki tög (type) eins og í Java, heldur hafa gildi tög. Þurfum ekki að skilgreina tagið á breytu.\n",
    "\n",
    "Helstu tög\n",
    "- Boolean: True/False\n",
    "- String: 'strengur', 'annar strengur'\n",
    "- Integer: 42\n",
    "- Float: 3.14159\n",
    "\n",
    "Til að finna tag á gildi notum við type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"strengur\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Breytur vísa á gildi, tagið á breytunni er þá sama og tagið á gildinu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "strengur\n",
      "10 strengur\n",
      "0.1\n",
      "0.10000000\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "strengur = 'strengur'\n",
    "n = 10\n",
    "x = 0.1\n",
    "\n",
    "# comment byrja á myllumerki\n",
    "\n",
    "print(n)\n",
    "print(strengur)\n",
    "print(n,strengur) # setur bil á milli\n",
    "print(x)\n",
    "print(\"%.8f\"%x) # prentar með 8 aukastöfum\n",
    "strengur = n\n",
    "print(strengur)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Heiltölur hegða sér eins og í Java, nema að þær hafa engin stærðartakmörk. Venjulegar reiknireglur gilda um `+,-,*,/,//,%,**` og `//` er heiltöludeiling en `/` er fleytitöludeiling (þetta breyttist í Python 3!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "0\n",
      "2\n",
      "0.6666666666666666\n",
      "8\n",
      "8.0\n",
      "179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 3\n",
    "print(a/b)\n",
    "print(a//b)\n",
    "print(a%b)\n",
    "print(a/float(b)) # skilar sama í python 2 og 3\n",
    "print(a**b)\n",
    "print(float(a)**b)\n",
    "print(2**1024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean\n",
    "\n",
    "Notum `==, <=,>=,<,>,!=` til að bera saman gildi.\n",
    "\n",
    "Boolean virkarnir heita `and,or,not` ekki `&&,||,!` eins og í Java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(0 <= x and x <= 10)\n",
    "print(0 <= x <= 10)\n",
    "print(True and True)\n",
    "print(True and not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stýrisetningar\n",
    "\n",
    "- if\n",
    "- for\n",
    "- while\n",
    "\n",
    "if stýrisetningin tekur inn Boolean gildi og keyrir segð ef gildið er True. Í python notum við ekki slaufusviga til að afmarka kóða heldur inndreginn kóða, venjið ykkur á að nota 4 bil, ekki tab merki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gildið á x er 10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "\n",
    "if x == 0:\n",
    "    print(\"x er 0\")\n",
    "print(\"Gildið á x er\",x) # ekki hluti af if"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If/else notar `elif` fyrir `else if` og eitt `else` án skilyrðis. Báðum síðustu má sleppa ef við þurfum þess ekki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fyrir hádegi\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "if 0 <= x < 12:\n",
    "    print(\"Fyrir hádegi\")\n",
    "elif 12 < x <= 24:\n",
    "    print(\"Eftir hádegi\")\n",
    "else:\n",
    "    print(\"Hádegi\")\n",
    "    func() # ekki skilgreint!\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While\n",
    "\n",
    "Endurtekur segð meðan skilyrði er True, skilyrðið er athugað í byrjun eins og í Java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x <= 10:\n",
    "    print(x)\n",
    "    #x = x + 1 # ekki gleyma þessu\n",
    "    x +=1\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For lykkjur\n",
    "\n",
    "Eru ekki á forminu `for(i =0; i < n; i++)`.\n",
    "\n",
    "Heldur ítrar for lykkjan yfir hluti með því að kalla á sérstakt fall.\n",
    "\n",
    "Til að fá heiltölur á bili notum við `range` fallið"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for x in range(5): # [0,5) 5 er stopp, ekki með \n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for x in range(1,6): # [1,6) byrjar 1 stoppar í 6, ekki með\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for x in range(2,11,2): # byrjar í 2, hoppar um tvö sæti og stoppar í 11\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`continue` og `break` hegða sér eins og í Java.\n",
    "\n",
    "Ef við viljum gera ekkert má ekki vera tóm lína heldur skrifum við `pass`. Gegnir sama hlutverki og `{}` í Java."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strengir\n",
    "\n",
    "Strengir hegða sér eins og listar og þeir eru óbreytanlegir eins og í Java.\n",
    "\n",
    "Við getum skeytt saman strengjum með `+`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab\n",
      "aaaaaaaaaabbbbbbbbbb\n"
     ]
    }
   ],
   "source": [
    "a = 'a'\n",
    "b = 'b'\n",
    "x = 1\n",
    "print(a + b)\n",
    "print(a*10+b*10) # margföldun er eins og margir plúsar\n",
    "#print(a+x) # heiltölum er ekki breytt í streng\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a1\n",
      "a1\n",
      "a1.000000\n"
     ]
    }
   ],
   "source": [
    "print(a+str(x)) # búum til streng úr int með str() smiðnum\n",
    "print(a+\"%d\"%x)\n",
    "print(a+\"%f\"%x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strengjaþýðing: við getum sparað okkur kall á `str` með því að nota `%` virkjann.\n",
    "\n",
    "Í strengnum eru `%d` fyrir heiltölur, `%s` fyrir strengi og `%f` fyrir fleytitölur. Til að framkvæma margar breytingar búum við til tuple sem er notað til að skeyta inn\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Heiltala: 1, Strengur: Halló, Float:1.000000, Float með 8 stöfum: 3.14159265\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(\"Heiltala: %d, Strengur: %s, Float:%f, Float með 8 stöfum: %.8f\"%(1,'Halló', 1.0, math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hlutstrengir: Við getum vísað í hluta af streng með\n",
    "\n",
    "- einni tölu, byrjað að telja í 0, t.d. s[0]\n",
    "- bili, s[0:10] \n",
    "- opnu bili, s[:5] eða s[1:]\n",
    "- og talið aftur á bak s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0\n",
      "23\n",
      "01234\n",
      "123456789\n",
      "9\n",
      "012345678\n",
      "02468\n",
      "9876543210\n"
     ]
    }
   ],
   "source": [
    "s = \"0123456789\"\n",
    "print(len(s)) #lengdin á s\n",
    "print(s[0])\n",
    "print(s[2:4])\n",
    "print(s[:5])\n",
    "print(s[1:])\n",
    "print(s[-1])\n",
    "print(s[:-1])\n",
    "print(s[::2])\n",
    "print(s[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Föll\n",
    "\n",
    "Notum `def` til að skilgreina fall, viðföngin hafa engin tög"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "HallóHalló\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    x = x + x\n",
    "    return x\n",
    "print(f(2))\n",
    "print(f('Halló'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Föll sem skila engu gildi skila gildinu `None`, fallið er þá eins og `void` í Java og `None` gegnir sama hlutverki og `null`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def h(x):\n",
    "    return print(x,x)\n",
    "y = h(1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Föll af föllum. Föll eru hlutir og geta verið viðföng inn í önnur föll."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n",
      "Halló\n",
      "None\n",
      "1.189207115002721\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def apply_twice(f,x):\n",
    "    return f(f(x))\n",
    "\n",
    "print(apply_twice(math.sqrt,4))\n",
    "apply_twice(print,'Halló')\n",
    "\n",
    "y = apply_twice\n",
    "\n",
    "print(y(math.sqrt,2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gildissvið\n",
    "Gildissvið (e. scope) breytu er innan fallsins sem hún er skilgreind í og skyggir á ytra svið (eins og í Java).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def modify(x):\n",
    "    x = x+1\n",
    "    print(x)\n",
    "    return None\n",
    "\n",
    "modify(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global breytur (ekki gera þetta)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def modify_global_wrong():\n",
    "    x = x+1\n",
    "    return x\n",
    "\n",
    "def modify_global_correct():\n",
    "    global x\n",
    "    x = x+1\n",
    "    return x\n",
    "\n",
    "#modify_global_wrong()\n",
    "modify_global_correct()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Föll sem skilagildi\n",
    "Við getum skilgreint ný föll inn í föllum og jafnvel skilað þeim. Eins geta nýju föllin vísað í breytur sem eru til inni í ytra fallinu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "<function adder.<locals>.f at 0x1052a9598>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def adder(x):\n",
    "    def f(y):\n",
    "        return x+y\n",
    "    return f\n",
    "\n",
    "h = adder(2)\n",
    "print(h(0))\n",
    "h2 = adder(4)\n",
    "print(h2(0))\n",
    "print(h)\n",
    "apply_twice(adder(2),4)\n",
    "#print(h.docstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda föll\n",
    "Föll sem eru á forminu \n",
    "```\n",
    "def fall(x):\n",
    "    return yrding_med_x\n",
    "```\n",
    "er hægt að skilgreina beint með lambda föllum.\n",
    "\n",
    "```\n",
    "fall = lambda x: yrding_med_x\n",
    "```\n",
    "\n",
    "Í Python má fallið bara vera ein yrðing, það er ekki hægt að nota `if,for,while` o.þ.h."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "fall = lambda x: x*x\n",
    "print(apply_twice(fall,2))\n",
    "print(apply_twice(lambda t: t+2,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function <lambda>.<locals>.<lambda> at 0x10524f950>\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "adder2 = lambda x: lambda y: x + y\n",
    "\n",
    "print(adder2(4))\n",
    "print(adder2(4)(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listar\n",
    "Listar í Python eru eins og fylki (eða Arraylist/Vector) í Java.\n",
    "\n",
    "- Stækka og minnka sig sjálfir eftir þörfum\n",
    "- Gildin þurfa ekki að vera af sama tagi\n",
    "- Getum breytt gildum, bætt við, tekið út\n",
    "- Tilvísanir eins og með strengi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, None, 'String']\n",
      "1\n",
      "None\n",
      "String\n",
      "[2, None]\n",
      "[4, 2, None, 'String']\n",
      "[2, None, 'String']\n",
      "[2, None, 'String', 1]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,None,'String']\n",
    "print(l)\n",
    "print(l[0])\n",
    "print(l[2])\n",
    "print(l[-1])\n",
    "print(l[1:3])\n",
    "l[0] = 4\n",
    "print(l)\n",
    "del l[0]\n",
    "print(l)\n",
    "l.append(1)\n",
    "print(l)\n",
    "print(len(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tómi listinn er táknaður með `[]`\n",
    "\n",
    "## Skeyting\n",
    "Við getum skeytt saman listum með `+` og líka margfaldað"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 4]\n",
      "[1, 2, 1, 2, 1, 2, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2]\n",
    "y = [2,4]\n",
    "print(x + y)\n",
    "print(x*4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listar geta líka innihaldið lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [1, 2]]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2]\n",
    "y = [x,x]\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4, 2], [4, 2]]\n"
     ]
    }
   ],
   "source": [
    "x[0] = 4\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Úbbs, hvað gerðist? y listinn var með tvær tilvísanir á sama hlut, þegar x breyttist þá vísar y ennþá á sama hlut.\n",
    "\n",
    "Við getum notað id fallið til að sjá tilvísunina"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4381238600 4381238600 4381238600\n"
     ]
    }
   ],
   "source": [
    "print(id(x),id(y[0]),id(y[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allt sama breytan. Til að fá gildin í x en ekki tilvísunina þurfum við að taka copy af x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4381238600 4381690824 4381689480\n"
     ]
    }
   ],
   "source": [
    "y = [list(x),list(x)] # köllum á lista smiðinn, sem býr til nýjan lista\n",
    "print(id(x),id(y[0]),id(y[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4381238600 4375890056 4375893192\n"
     ]
    }
   ],
   "source": [
    "y = [x[:],x[:]] # sama hugmynd, knappari ritháttur\n",
    "print(id(x),id(y[0]),id(y[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gagnleg föll\n",
    "- len skilar lengd á listanum, eins og fyrir strengi\n",
    "- append bætir einu staki við listann\n",
    "- enumerate er gott fyrir ítrun\n",
    "- range(n) skilar lista í Python 2 en sérstökum hlut í Python 3.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "a = 1\n",
      "a = 2\n",
      "a = 3\n",
      "a = 4\n",
      "a = 5\n",
      "x[0] = 1\n",
      "x[1] = 2\n",
      "x[2] = 3\n",
      "x[3] = 4\n",
      "x[4] = 5\n",
      "x[0] = 1\n",
      "x[1] = 2\n",
      "x[2] = 3\n",
      "x[3] = 4\n",
      "x[4] = 5\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4]\n",
    "print(len(x))\n",
    "x.append(5)\n",
    "print(len(x))\n",
    "\n",
    "for a in x:\n",
    "    print(\"a =\",a)\n",
    "    \n",
    "for i,a in enumerate(x): # enumerate ítrar yfir par af sæti og gildi\n",
    "    print(\"x[%d] = %d\"%(i,a))\n",
    "    \n",
    "#jafngilt\n",
    "for i in range(len(x)):\n",
    "    a = x[i]\n",
    "    print(\"x[%d] = %d\"%(i,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "range(0, 10)\n",
      "<class 'list'>\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "x = range(n)\n",
    "print(type(x))\n",
    "print(x)\n",
    "y = list(x) # pínum range hlutinn yfir í lista\n",
    "print(type(y))\n",
    "print(y)\n",
    "z = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 100]\n"
     ]
    }
   ],
   "source": [
    "y  = [100] + list(range(10)) + [100] # smá hint\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}