Module 2 -> Python Syntax .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This lecture is best experienced together.\n",
    "In 90 minutes, I'll give you 20 python codes, and you need to explain why they do what they do. I'll help you out by saying \"yes\" or \"no\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Stefan and Damon!\n"
     ]
    }
   ],
   "source": [
    "# 1\n",
    "print('Hello, Stefan and Damon!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Yourself. We're here to drink blood.\n",
      "Hello Yourself. We're here to drink blood.\n",
      "Hello Yourself. We're here to drink blood.\n",
      "Hello Yourself. We're here to drink blood.\n"
     ]
    }
   ],
   "source": [
    "# 2\n",
    "for i in range(4):\n",
    "    print(\"Hello Yourself. We're here to drink blood.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Crabbe', 'Dolohov', 'Lestrange']\n"
     ]
    }
   ],
   "source": [
    "# 3\n",
    "good_people = ['Harry', 'Ron', 'Hermy']\n",
    "death_eaters = ['Crabbe', 'Dolohov', 'Lestrange']\n",
    "the_world = ['Harry', 'Ron', 'Hermy', 'Crabbe', 'Dolohov', 'Lestrange', 'Snape', 'Dumbledore', 'Fred']\n",
    "\n",
    "print(death_eaters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Harry hates Crabbe\n",
      "Harry hates Dolohov\n",
      "Harry hates Lestrange\n",
      "Ron hates Crabbe\n",
      "Ron hates Dolohov\n",
      "Ron hates Lestrange\n",
      "Hermy hates Crabbe\n",
      "Hermy hates Dolohov\n",
      "Hermy hates Lestrange\n"
     ]
    }
   ],
   "source": [
    "# 4\n",
    "for g in good_people:\n",
    "    for deathEater in death_eaters:\n",
    "        print(f'{g} hates {deathEater}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The world isn't split between good people and death eaters\n"
     ]
    }
   ],
   "source": [
    "# 5\n",
    "if the_world != good_people + death_eaters:\n",
    "    print(\"The world isn't split between good people and death eaters\")\n",
    "else:\n",
    "    print('It is easy to see that nearly six years of magical education have not been wasted on you')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "None\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 6\n",
    "print((False and False))\n",
    "print(not (False and False))\n",
    "print(None)\n",
    "print(not None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'list'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "<class 'float'>\n",
      "<class 'NoneType'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# 6\n",
    "\n",
    "for variable in ['u', \"hitchhiker\", 42, [1.618,'asdf',3.141592,4], 'galaxy', True, 1., None, not None]:\n",
    "    print(type(variable))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the fault is in our face\n"
     ]
    }
   ],
   "source": [
    "# 7 \n",
    "\n",
    "print(\"the fault is\" + \" in our face\")\n",
    "# y u no print me?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 8\n",
    "\n",
    "53 + (-11 // 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 9\n",
    "\n",
    "def one_punch_man(enemy):\n",
    "    '''\n",
    "    - OPMs reactions to various enemies\n",
    "    - input: enemy (string)\n",
    "    - output: reaction (string)\n",
    "    '''\n",
    "    if enemy == 'Garou':\n",
    "        return \"Serious Punch.\"\n",
    "        \n",
    "    elif enemy == 'Boros':\n",
    "        return \"Consecutive Normal Punches.\"\n",
    "    else:\n",
    "        return \"punch\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Serious Punch.\n",
      "Consecutive Normal Punches.\n",
      "punch\n",
      "Serious Punch.\n"
     ]
    }
   ],
   "source": [
    "# 10\n",
    "\n",
    "villains = ['Garou', 'Boros', 'Marugori']\n",
    "villains.append('Garou')\n",
    "for v in villains:\n",
    "    print(one_punch_man(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# 11\n",
    "\n",
    "bbt_gfs = {\n",
    "    'sheldon': 'amy',\n",
    "    'leonard': 'penny',\n",
    "    'kurt': 'penny',\n",
    "    'zack': 'penny',\n",
    "    'leonard': 'priya',\n",
    "    'raj': None\n",
    "}\n",
    "\n",
    "print(type(bbt_gfs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amy\n",
      "priya\n",
      "5\n",
      "bernadette\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# 12\n",
    "\n",
    "print(bbt_gfs['sheldon'])\n",
    "print(bbt_gfs['leonard'])\n",
    "print(len(bbt_gfs))\n",
    "bbt_gfs['howard'] = 'bernadette'\n",
    "print(bbt_gfs['howard'])\n",
    "print(len(bbt_gfs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carmela\n",
      "['Livia', 'AJ']\n",
      "AJ\n",
      "6\n",
      "['Carmela', 'Junior', 'Livia', 'AJ', 'Janice']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# 13 \n",
    "\n",
    "sopranos = ['Tony', 'Carmela', 'Junior', 'Livia', 'AJ']\n",
    "print(sopranos[1])\n",
    "print(sopranos[3:])\n",
    "print(sopranos[-1])\n",
    "sopranos = sopranos + ['Janice']\n",
    "print(len(sopranos))\n",
    "del sopranos[0]\n",
    "print(sopranos)\n",
    "sopranos.clear()\n",
    "print(sopranos)\n",
    "\n",
    "# look later: extend, insert, remove, pop, index, count, reverse, copy, etc from docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is NOT a prime\n",
      "2 is a prime\n",
      "3 is a prime\n",
      "4 is 2 times 2\n",
      "5 is a prime\n",
      "6 is 2 times 3\n",
      "7 is a prime\n",
      "8 is 2 times 4\n",
      "9 is 3 times 3\n",
      "10 is 2 times 5\n",
      "11 is a prime\n",
      "12 is 2 times 6\n"
     ]
    }
   ],
   "source": [
    "# 14 \n",
    "\n",
    "# tells if all numbers till n are primes, or gives their factorization\n",
    "def primes(n):\n",
    "    \n",
    "    print('1 is NOT a prime')\n",
    "    \n",
    "    for i in range(2,n):\n",
    "        for j in range(2,i):\n",
    "            if i % j == 0:\n",
    "                print(i, 'is', j, 'times', i//j)\n",
    "                break\n",
    "        else:\n",
    "            print(i, 'is a prime')\n",
    "            \n",
    "primes(13)\n",
    "\n",
    "# cover pep8 in a later lecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Drogon', 'Rhaegal', 'Viserion']\n"
     ]
    }
   ],
   "source": [
    "# 15 \n",
    "\n",
    "dany_kids = ['Drogon', 'Rhaegal', 'Tyrion']\n",
    "\n",
    "dany_kids[2] = 'Viserion'\n",
    "\n",
    "print(dany_kids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "# 16\n",
    "\n",
    "squares = [x**2 for x in range(10)]\n",
    "print(squares)\n",
    "print(squares[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "krazy-8\n"
     ]
    }
   ],
   "source": [
    "# 17\n",
    "\n",
    "t = 'heisenberg', 'skinny pete', 'badger', 'krazy-8', 'JP'\n",
    "print(type(t))\n",
    "print(t[3])\n",
    "\n",
    "#t[2] = 'skyler'\n",
    "\n",
    "# cover benefits of tuples over lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18 \n",
    "\n",
    "import random\n",
    "\n",
    "candidates = ['Francis', 'Conway', 'Claire', 'Brockhart']\n",
    "num_voters = 42\n",
    "\n",
    "# the bad python way\n",
    "\n",
    "def bad_voting(num, candidates):\n",
    "    votes = []\n",
    "    num_candidates = len(candidates)\n",
    "    for i in range(num):\n",
    "        temp = random.randint(0, num_candidates-1)\n",
    "        votes.append(candidates[temp])\n",
    "    return votes\n",
    "\n",
    "def bad_winner(votes):\n",
    "    uniq_cands = []\n",
    "    for cand in votes:\n",
    "        if cand not in uniq_cands:\n",
    "            uniq_cands.append(cand)\n",
    "            \n",
    "    freq_cands = {}\n",
    "    \n",
    "    for cand in uniq_cands:\n",
    "        freq_cands[cand] = 0\n",
    "    \n",
    "    for cand in votes:\n",
    "        freq_cands[cand] += 1\n",
    "        \n",
    "    winner = None\n",
    "    winner_votes = 0\n",
    "    \n",
    "    for cand in uniq_cands:\n",
    "        if freq_cands[cand] > winner_votes:\n",
    "            winner_votes = freq_cands[cand]\n",
    "            winner = cand\n",
    "    \n",
    "    return winner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 19\n",
    "\n",
    "# the pythonic way\n",
    "\n",
    "def voting(num, candidates):\n",
    "    return [random.choice(candidates) for _ in range(num)]\n",
    "\n",
    "def winner(votes):\n",
    "    return max(votes, key=votes.count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Francis\n",
      "Francis\n"
     ]
    }
   ],
   "source": [
    "seed_value = 6\n",
    "\n",
    "random.seed(seed_value)\n",
    "print(winner(voting(num_voters, candidates)))\n",
    "\n",
    "random.seed(seed_value)\n",
    "print(bad_winner(bad_voting(num_voters, candidates)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 20 \n",
    "\n",
    "#! cat sherlock.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "there\n",
      "2587\n"
     ]
    }
   ],
   "source": [
    "pattern = input()\n",
    "\n",
    "f = open('sherlock.txt', 'r')\n",
    "\n",
    "count = 0\n",
    "\n",
    "for line in f:\n",
    "    for word in line.split():\n",
    "        if word.lower() == pattern:\n",
    "            count += 1\n",
    "f.close()\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thank You.\n"
     ]
    }
   ],
   "source": [
    "print('Thank You.')\n",
    "\n",
    "# cover classes in a separate lecture\n",
    "# implementation of term project template from scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PS: Sorry for it being \"the one where we missed your favorite show\"\n"
     ]
    }
   ],
   "source": [
    "print('PS: Sorry for it being \"the one where we missed your favorite show\"')"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}