homework2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"frontmatter text-center\">\n",
    "<h2> MATH5027 Scientific Python, Fall 2017</h2>\n",
    "<h2> Homework 2, Due: Monday October 2nd, 3pm </h2>\n",
    "</div>\n",
    "\n",
    "Instructions: complete the selection of exercises from the week's class notebooks. Use markdown cells between code examples to explain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions \n",
    "### From Class 2:\n",
    "\n",
    "1) From the BKK website scraping task, select all the annual and quarterly tickets. How much do you save if you buy four quarterly tickets instead of one annual ticket (use the average price)? Please focus on coding - the point is not to get exactly the 'right' answer, but to show code that downloads the page, parses the html text in a reasonable way, and makes a reasonable inference about the question.\n",
    "\n",
    "2) Use ```%timeit``` (see questions asked during the first class) to check the best time to create ```mylist1``` and ```%%timeit``` for creating ```mylist2```, both defined in the cells below. Which one is faster? Any guess why? \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLASS 2, ASSIGMENT 1.\n",
    "--------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#The original scraping code to make assigment work through this notebook. \n",
    "import urllib.request\n",
    "request = urllib.request.Request('http://www.bkk.hu/en/tickets-and-passes/prices/')\n",
    "result = urllib.request.urlopen(request)\n",
    "text = result.read() #'text' is the name of the object where we store the string of code behind the bkk.info page\n",
    "text=str(text)\n",
    "splitted=text.split('<div><span>')\n",
    "\n",
    "type_ticket=[]\n",
    "for element in splitted[1::2]: #[start:end:step] = > starting at index 1 stepping by 2; this is the ticket types\n",
    "    #print element\n",
    "    temp=element.split('</span></div>')[0]\n",
    "    ticket=temp[temp.find('>')+len('>'):temp.rfind('</a')]\n",
    "    type_ticket.append(ticket)\n",
    "\n",
    "price=[]\n",
    "for element in splitted[2::2]: # at number two start the prices\n",
    "    temp=element.split('</span></div>')[0]\n",
    "    price.append(temp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quarterly prices:  [28500, 31500, 10350, 10350, 9990]\n",
      "Annual prices:  [217960, 219860, 9500, 10500]\n"
     ]
    }
   ],
   "source": [
    "#The new stuff\n",
    "\n",
    "quarterly_tickets = []\n",
    "quarterly_prices = []\n",
    "\n",
    "for element in type_ticket[0:]:\n",
    "    if element[0:5] == \"Quart\":\n",
    "        quarterly_tickets.append(element)\n",
    "        idx = type_ticket.index(element)\n",
    "        quarterly_prices.append(price[idx])\n",
    "        \n",
    "    \n",
    "annual_tickets = []\n",
    "annual_prices = []\n",
    "for element in type_ticket[0:]:\n",
    "    if element[0:5] == \"Annua\":\n",
    "        annual_tickets.append(element)\n",
    "        idx = type_ticket.index(element)\n",
    "        annual_prices.append(price[idx])\n",
    "        \n",
    "quarterly_prices_num = []\n",
    "for element in quarterly_prices:\n",
    "    pr = ''.join([q for q in element if q.isdigit()])\n",
    "    pr = int (pr)\n",
    "    quarterly_prices_num.append(pr)\n",
    "print(\"Quarterly prices: \", quarterly_prices_num)\n",
    "\n",
    "annual_prices_num = []\n",
    "for element in annual_prices:\n",
    "    pr = ''.join([q for q in element if q.isdigit()])\n",
    "    pr = int (pr)\n",
    "    annual_prices_num.append(pr)\n",
    "print(\"Annual prices: \", annual_prices_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: as annual Budapest-passes are given on a per month basis, all of the array's elements are not directly comparable. This way the following calculation gives misleading results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The difference between avg quarterly and annual prices: -10475.75 forints.\n"
     ]
    }
   ],
   "source": [
    "average_quarterly_price = sum(quarterly_prices_num) / len(quarterly_prices_num)\n",
    "average_annual_price = sum(annual_prices_num) / len(annual_prices_num)\n",
    "print(\"The difference between avg quarterly and annual prices:\", average_quarterly_price - average_annual_price/4, \"forints.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLASS 2, ASSIGMENT 2\n",
    "--------------------------------------------------------------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n"
     ]
    }
   ],
   "source": [
    "#mylist1 definition for Class2/Question2\n",
    "mylist1=[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]\n",
    "print(mylist1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n"
     ]
    }
   ],
   "source": [
    "#mylist2 definition for Class2/Question2\n",
    "mylist2=[]\n",
    "for x in [1,2,3]:\n",
    "    for y in [3,1,4]:\n",
    "        if x!=y:\n",
    "            mylist2.append((x,y))\n",
    "print(mylist2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000000 loops, best of 3: 21.7 ns per loop\n",
      "10000000 loops, best of 3: 21.7 ns per loop\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "%timeit(mylist1)\n",
    "%timeit(mylist2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a matter of fact, I have run %timeit a few times and the results have not been consistent. But at least I can run it :) It is interesting though, that on stackoverflow I have not yet found a proper how-to-do for %timeit. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### From Class 3:\n",
    "\n",
    "1) Create a different sorting function - invent one - that works with strings.\n",
    "\n",
    "2) Define a function called both_ends: Given a string s, return a string made of the first 2 and the last 2 chars of the original string, so 'spring' yields 'spng'. However, if the string length  is less than 2, return instead the empty string.\n",
    "\n",
    "2) I have hidden strings containing the family names (no accents or special characters):\n",
    "`Ang`, `Baida`, `Baroma`, `Boza`, `Chen`, `Craciun`, `Czobor`, `Dezsenyi`, `Drucker`, `Duronelly`, `Fleck`, `Gabriel`, `Juhasz`, `Karimli`, `Kattika`, `Kazmina`, `Kripalani`, `Lukacs`, `Mattos`, `Mekhrishvili`, `Menyhert`, `Molnar`, `Mark`, `Natera`, `Neri`, `Oleksandrenko`, `Strabel`, `Szabo`, `Yetkin`, `Zhu`, \n",
    "as well as the string `Sinatra.Roberta` in the html code of one the pages of my website http://www.robertasinatra.com. \n",
    "\n",
    "Write a program that:\n",
    "* crawls the html code of the homepage `http://www.robertasinatra.com/index.html`;\n",
    "* finds all other html pages that are contained in index.html and that refer to the main domain www.robertasinatra.com (e.g. `research.html`) - this step should be done automatically, you cannot list the html pages manually.\n",
    "* searches your family name, as listed above (no accents and special characters), in the html code of these pages. Should your family name not being included in the list above, search for `Sinatra.Roberta`. Note that different names are in different pages and that the name might appear in the pages in lower case, upper case or a combination of the two;\n",
    "* prints on screen ‘My family name is hidden in ...’ , where ... is substituted with the address of the html page containing your family name.\n",
    "Note: I have not hidden the name in html pages that are not linked in `index.html`, like `www.robertasinatra.com/teaching/math5027.html`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLASS 3, ASSIGNMENT 1\n",
    "------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Borsodi', 'Carlsberg', 'Guinnes', 'Heineken', 'Krombacher', 'Paulaner', 'Pilsner', 'Soproni', 'Budvar', 'Ciuc', 'Dreher', 'Tuborg']\n"
     ]
    }
   ],
   "source": [
    "# Sorting rule: words are sorted first if they are of than 6 characters long; words of 6 or less characters are sorted  \n",
    "# afterwords and then appended.\n",
    "\n",
    "def longsort(words):\n",
    "    words_long = []\n",
    "    words_short = []\n",
    "    for element in words:\n",
    "        if len(element) > 6:\n",
    "            words_long.append(element)\n",
    "        else: \n",
    "            words_short.append(element)\n",
    "    words_short = sorted(words_short)\n",
    "    words_long = sorted(words_long)\n",
    "    for item in words_short:\n",
    "        words_long.append(item)\n",
    "    return words_long\n",
    "\n",
    "worte = [\"Heineken\", \"Borsodi\", \"Pilsner\", \"Budvar\", \"Dreher\", \"Paulaner\", \"Carlsberg\", \n",
    "         \"Tuborg\", \"Soproni\", \"Krombacher\", \"Ciuc\",\"Guinnes\"]\n",
    "xworte = longsort(worte)\n",
    "print(xworte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLASS 3, ASSIGMENT 1, A FAILED ALTERNATIVE VERSION\n",
    "--"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Johannes, I was trying to creat a sorting algo which sorts words by length and then by alphabetical order within the list of words of \n",
    "# equal length. The for cycle, however, seems to omit certain elements in my lists: it looks that the for cycle in line 23\n",
    "# misses every other element in temp_lista. It also misses array elements in the cacyle of line 16.\n",
    "# (I added the print commands to see what's going on inside the arrays.)\n",
    "\n",
    "## Can we have a few words about it before class? Or afterwards?\n",
    "#(This was my original plan for the assigment but I just couldn't figure out what I have done wrong here.)\n",
    "\n",
    "def mysort(ip_lista):\n",
    "    temp_lista= []\n",
    "    op_lista = []\n",
    "    \n",
    "    print(\"in\", len(ip_lista))\n",
    "    \n",
    "    max_word_length = len(max(ip_lista, key = lambda word: len(word)))\n",
    "    min_word_length = len(min(ip_lista, key = lambda word: len(word)))\n",
    "    print(\"min_word_length\", min_word_length)\n",
    "    print(\"max_word_length\", max_word_length)\n",
    "    #print(max_word_length, min_word_length)\n",
    "    for x in range(min_word_length, max_word_length+1):\n",
    "        for word in ip_lista:\n",
    "            if len(word) == x:\n",
    "                temp_lista.append(word)\n",
    "                #ip_lista.remove(word)\n",
    "        temp_lista = sorted(temp_lista)\n",
    "        print(\"temp1:\", temp_lista)\n",
    "        for element in temp_lista:\n",
    "            op_lista.append(element)\n",
    "        temp_lista = []\n",
    "        \n",
    "        print(\"in:\", ip_lista)\n",
    "        print(\"temp 2:\", temp_lista)\n",
    "        print(\"out:\", op_lista)\n",
    "        print(\"------------------\")\n",
    "            \n",
    "    print(\"in\", len(ip_lista))\n",
    "    print(\"out\", len(op_lista))\n",
    "    \n",
    "    return \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in 21\n",
      "min_word_length 3\n",
      "max_word_length 12\n",
      "temp1: ['BBB']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB']\n",
      "------------------\n",
      "temp1: ['Audi', 'Fiat', 'Ford']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford']\n",
      "------------------\n",
      "temp1: ['Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo']\n",
      "------------------\n",
      "temp1: ['Barkas', 'Lancia', 'Toyota']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota']\n",
      "------------------\n",
      "temp1: ['Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota', 'Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach']\n",
      "------------------\n",
      "temp1: ['Chrysler', 'Mercedes']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota', 'Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach', 'Chrysler', 'Mercedes']\n",
      "------------------\n",
      "temp1: []\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota', 'Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach', 'Chrysler', 'Mercedes']\n",
      "------------------\n",
      "temp1: ['Alfa Romeo']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota', 'Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach', 'Chrysler', 'Mercedes', 'Alfa Romeo']\n",
      "------------------\n",
      "temp1: []\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota', 'Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach', 'Chrysler', 'Mercedes', 'Alfa Romeo']\n",
      "------------------\n",
      "temp1: ['Aston Martin']\n",
      "in: ['Audi', 'BBB', 'Volvo', 'Mercedes', 'Maybach', 'Toyota', 'Chrysler', 'Fiat', 'Alfa Romeo', 'Aston Martin', 'Barkas', 'Bedford', 'Bentley', 'Citroen', 'Dacia', 'Daewo', 'Ferrari', 'Ford', 'Honda', 'Lancia', 'Lexus']\n",
      "temp 2: []\n",
      "out: ['BBB', 'Audi', 'Fiat', 'Ford', 'Dacia', 'Daewo', 'Honda', 'Lexus', 'Volvo', 'Barkas', 'Lancia', 'Toyota', 'Bedford', 'Bentley', 'Citroen', 'Ferrari', 'Maybach', 'Chrysler', 'Mercedes', 'Alfa Romeo', 'Aston Martin']\n",
      "------------------\n",
      "in 21\n",
      "out 21\n"
     ]
    }
   ],
   "source": [
    "autos = [\"Audi\", \"BBB\", \"Volvo\", \"Mercedes\", \"Maybach\", \"Toyota\", \"Chrysler\", \"Fiat\", \"Alfa Romeo\",\"Aston Martin\", \"Barkas\", \"Bedford\",\"Bentley\", \"Citroen\", \"Dacia\",\"Daewo\",\"Ferrari\",\"Ford\", \"Honda\",\"Lancia\",\"Lexus\"]\n",
    "cars = [\"Audi\",\"VW\",\"Volvo\", \"Dacia\", \"Fiat\", \"Daewo\", \"Honda\"]\n",
    "mysort(autos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mysort_alt(ip_lista):\n",
    "    temp_lista= []\n",
    "    op_lista = []\n",
    "    \n",
    "    print(\"in\", len(ip_lista))\n",
    "    \n",
    "    max_word_length = len(max(ip_lista, key = lambda word: len(word)))\n",
    "    min_word_length = len(min(ip_lista, key = lambda word: len(word)))\n",
    "    print(\"min_word_length\", min_word_length)\n",
    "    print(\"max_word_length\", max_word_length)\n",
    "    #print(max_word_length, min_word_length)\n",
    "    for x in range(min_word_length, max_word_length+1):\n",
    "        \n",
    "        print(\"*****\")\n",
    "        print(\"Current length:\",x)\n",
    "        for word in ip_lista:\n",
    "            print(word, len(word))\n",
    "            if len(word) == x:\n",
    "                print(\"Kiválasztva: (\",x,\")\", word)\n",
    "                #temp_lista.append(word)\n",
    "                #ip_lista.remove(word)\n",
    "        #temp_lista = sorted(temp_lista)\n",
    "        #print(\"temp1:\", temp_lista)\n",
    "        #for element in temp_lista:\n",
    "        #    op_lista.append(element)\n",
    "        #temp_lista = []\n",
    "        \n",
    "        #print(\"in:\", ip_lista)\n",
    "        #print(\"temp 2:\", temp_lista)\n",
    "        #print(\"out:\", op_lista)\n",
    "        #print(\"------------------\")\n",
    "            \n",
    "    #print(\"in\", len(ip_lista))\n",
    "    #print(\"out\", len(op_lista))\n",
    "    \n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in 21\n",
      "min_word_length 3\n",
      "max_word_length 12\n",
      "*****\n",
      "Current length: 3\n",
      "Audi 4\n",
      "BBB 3\n",
      "Kiválasztva: ( 3 ) BBB\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 4\n",
      "Audi 4\n",
      "Kiválasztva: ( 4 ) Audi\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Kiválasztva: ( 4 ) Fiat\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Kiválasztva: ( 4 ) Ford\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 5\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Kiválasztva: ( 5 ) Volvo\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Kiválasztva: ( 5 ) Dacia\n",
      "Daewo 5\n",
      "Kiválasztva: ( 5 ) Daewo\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Kiválasztva: ( 5 ) Honda\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "Kiválasztva: ( 5 ) Lexus\n",
      "*****\n",
      "Current length: 6\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Kiválasztva: ( 6 ) Toyota\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Kiválasztva: ( 6 ) Barkas\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Kiválasztva: ( 6 ) Lancia\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 7\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Kiválasztva: ( 7 ) Maybach\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Kiválasztva: ( 7 ) Bedford\n",
      "Bentley 7\n",
      "Kiválasztva: ( 7 ) Bentley\n",
      "Citroen 7\n",
      "Kiválasztva: ( 7 ) Citroen\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Kiválasztva: ( 7 ) Ferrari\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 8\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Kiválasztva: ( 8 ) Mercedes\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Kiválasztva: ( 8 ) Chrysler\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 9\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 10\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Kiválasztva: ( 10 ) Alfa Romeo\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 11\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n",
      "*****\n",
      "Current length: 12\n",
      "Audi 4\n",
      "BBB 3\n",
      "Volvo 5\n",
      "Mercedes 8\n",
      "Maybach 7\n",
      "Toyota 6\n",
      "Chrysler 8\n",
      "Fiat 4\n",
      "Alfa Romeo 10\n",
      "Aston Martin 12\n",
      "Kiválasztva: ( 12 ) Aston Martin\n",
      "Barkas 6\n",
      "Bedford 7\n",
      "Bentley 7\n",
      "Citroen 7\n",
      "Dacia 5\n",
      "Daewo 5\n",
      "Ferrari 7\n",
      "Ford 4\n",
      "Honda 5\n",
      "Lancia 6\n",
      "Lexus 5\n"
     ]
    }
   ],
   "source": [
    "mysort_alt(autos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLASS 3, ASSIGMENT 2\n",
    "--"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def both_ends(s):\n",
    "    if len(s) < 2:\n",
    "        output = \"\"\n",
    "    else:\n",
    "        output = s[0:2] + s[-2] + s[-1]\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Nida'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "both_ends(\"Niki Lauda\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLASS 3, ASSIGMENT 3\n",
    "--"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name can be found on the http://www.robertasinatra.com/research.html page.\n"
     ]
    }
   ],
   "source": [
    "import urllib.request\n",
    "request = urllib.request.Request('http://www.robertasinatra.com/index.html')\n",
    "result = urllib.request.urlopen(request)\n",
    "text = result.read() #'text' is the name of the object where we store the string of code behind the bkk.info page\n",
    "text = str(text)\n",
    "\n",
    "splitted=text.split(\" href=\")\n",
    "\n",
    "for splits in splitted:\n",
    "    if splits.find(\".html\") != -1 and splits.find(\"http\") == -1:\n",
    "        stop = splits.index(\"html\")\n",
    "        url = \"http://www.robertasinatra.com/\" + splits[1:stop-1] + \".html\"\n",
    "        request = urllib.request.Request(url)\n",
    "        result = urllib.request.urlopen(request)\n",
    "        subtext = result.read()\n",
    "        subtext = str(subtext)\n",
    "        subtext = subtext.upper()\n",
    "        if subtext.find(\"DURONELLY\") != -1:\n",
    "            print (\"My name can be found on the\", url, \"page.\")"
   ]
  },
  {
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}