1 - Introduction to Python (key).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "399855b0",
   "metadata": {},
   "source": [
    "# Introduction to Python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36c4f14a",
   "metadata": {},
   "source": [
    "## Basic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fc436f9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6231669f",
   "metadata": {},
   "source": [
    "It can store variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "792c292c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=5\n",
    "y=10\n",
    "\n",
    "x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c049dbe",
   "metadata": {},
   "source": [
    "## Basic Datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cd5c178",
   "metadata": {},
   "source": [
    "It has several datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1f0dd216",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12 # integer: -2, -1, 0, 1, 2, 3, 4, 5, 100\n",
    "b = -14.2 # float: -3.14159265358979, 45.2\n",
    "c = 'test' # string: any sequence of characters\n",
    "c = \"test\" # string (2)\n",
    "d = True # boolean: is either True or False\n",
    "d = False\n",
    "e = [1, 2, 3, 4, 5, 'tea', 'orange', -14.2, [2, 3, 4]]\n",
    "f = (1, 2, 'tea')\n",
    "g = None # none or null datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afa0751a",
   "metadata": {},
   "source": [
    "Accessing values in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b2634af4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tea'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9994c965",
   "metadata": {},
   "source": [
    "## List vs. Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ae2314f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_example = [1, 2, 3, 4] # this is a list\n",
    "tuple_example = (1,2,3,4) # this is a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d35cd25",
   "metadata": {},
   "source": [
    "lists can be edited, but tuples cannot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "120a0fb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 12]\n"
     ]
    }
   ],
   "source": [
    "print(list_example)\n",
    "list_example[3] = 12\n",
    "print(list_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "787ac806",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    },
    {
     "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<ipython-input-20-cae3581daae0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtuple_example\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtuple_example\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m12\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtuple_example\u001b[0m\u001b[1;33m)\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": [
    "print(tuple_example)\n",
    "tuple_example[3] = 12\n",
    "print(tuple_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3776fd4c",
   "metadata": {},
   "source": [
    "## Dictionary\n",
    "dictionaries are composed of keys and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "37412c69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "dict_obj = {'key1': 1, 'key2': 20}\n",
    "print(dict_obj['key2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1b893c05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_obj['key1'] = 5\n",
    "dict_obj['key1']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2eab944",
   "metadata": {},
   "source": [
    "# Coding Structures\n",
    "\n",
    "if statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "75b09e1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n"
     ]
    }
   ],
   "source": [
    "if (x+4 == 10):\n",
    "    print('apple')\n",
    "else:\n",
    "    print('banana')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "359e280a",
   "metadata": {},
   "source": [
    "for/while loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9f3ef84f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "tea\n",
      "orange\n",
      "-14.2\n",
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "for i in e:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e73c706e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-300\n",
      "-299\n",
      "-298\n",
      "-297\n",
      "-296\n",
      "-295\n",
      "-294\n",
      "-293\n",
      "-292\n",
      "-291\n",
      "-290\n",
      "-289\n",
      "-288\n",
      "-287\n",
      "-286\n",
      "-285\n",
      "-284\n",
      "-283\n",
      "-282\n",
      "-281\n",
      "-280\n",
      "-279\n",
      "-278\n",
      "-277\n",
      "-276\n",
      "-275\n",
      "-274\n",
      "-273\n",
      "-272\n",
      "-271\n",
      "-270\n",
      "-269\n",
      "-268\n",
      "-267\n",
      "-266\n",
      "-265\n",
      "-264\n",
      "-263\n",
      "-262\n",
      "-261\n",
      "-260\n",
      "-259\n",
      "-258\n",
      "-257\n",
      "-256\n",
      "-255\n",
      "-254\n",
      "-253\n",
      "-252\n",
      "-251\n",
      "-250\n",
      "-249\n",
      "-248\n",
      "-247\n",
      "-246\n",
      "-245\n",
      "-244\n",
      "-243\n",
      "-242\n",
      "-241\n",
      "-240\n",
      "-239\n",
      "-238\n",
      "-237\n",
      "-236\n",
      "-235\n",
      "-234\n",
      "-233\n",
      "-232\n",
      "-231\n",
      "-230\n",
      "-229\n",
      "-228\n",
      "-227\n",
      "-226\n",
      "-225\n",
      "-224\n",
      "-223\n",
      "-222\n",
      "-221\n",
      "-220\n",
      "-219\n",
      "-218\n",
      "-217\n",
      "-216\n",
      "-215\n",
      "-214\n",
      "-213\n",
      "-212\n",
      "-211\n",
      "-210\n",
      "-209\n",
      "-208\n",
      "-207\n",
      "-206\n",
      "-205\n",
      "-204\n",
      "-203\n",
      "-202\n",
      "-201\n",
      "-200\n",
      "-199\n",
      "-198\n",
      "-197\n",
      "-196\n",
      "-195\n",
      "-194\n",
      "-193\n",
      "-192\n",
      "-191\n",
      "-190\n",
      "-189\n",
      "-188\n",
      "-187\n",
      "-186\n",
      "-185\n",
      "-184\n",
      "-183\n",
      "-182\n",
      "-181\n",
      "-180\n",
      "-179\n",
      "-178\n",
      "-177\n",
      "-176\n",
      "-175\n",
      "-174\n",
      "-173\n",
      "-172\n",
      "-171\n",
      "-170\n",
      "-169\n",
      "-168\n",
      "-167\n",
      "-166\n",
      "-165\n",
      "-164\n",
      "-163\n",
      "-162\n",
      "-161\n",
      "-160\n",
      "-159\n",
      "-158\n",
      "-157\n",
      "-156\n",
      "-155\n",
      "-154\n",
      "-153\n",
      "-152\n",
      "-151\n",
      "-150\n",
      "-149\n",
      "-148\n",
      "-147\n",
      "-146\n",
      "-145\n",
      "-144\n",
      "-143\n",
      "-142\n",
      "-141\n",
      "-140\n",
      "-139\n",
      "-138\n",
      "-137\n",
      "-136\n",
      "-135\n",
      "-134\n",
      "-133\n",
      "-132\n",
      "-131\n",
      "-130\n",
      "-129\n",
      "-128\n",
      "-127\n",
      "-126\n",
      "-125\n",
      "-124\n",
      "-123\n",
      "-122\n",
      "-121\n",
      "-120\n",
      "-119\n",
      "-118\n",
      "-117\n",
      "-116\n",
      "-115\n",
      "-114\n",
      "-113\n",
      "-112\n",
      "-111\n",
      "-110\n",
      "-109\n",
      "-108\n",
      "-107\n",
      "-106\n",
      "-105\n",
      "-104\n",
      "-103\n",
      "-102\n",
      "-101\n",
      "-100\n",
      "-99\n",
      "-98\n",
      "-97\n",
      "-96\n",
      "-95\n",
      "-94\n",
      "-93\n",
      "-92\n",
      "-91\n",
      "-90\n",
      "-89\n",
      "-88\n",
      "-87\n",
      "-86\n",
      "-85\n",
      "-84\n",
      "-83\n",
      "-82\n",
      "-81\n",
      "-80\n",
      "-79\n",
      "-78\n",
      "-77\n",
      "-76\n",
      "-75\n",
      "-74\n",
      "-73\n",
      "-72\n",
      "-71\n",
      "-70\n",
      "-69\n",
      "-68\n",
      "-67\n",
      "-66\n",
      "-65\n",
      "-64\n",
      "-63\n",
      "-62\n",
      "-61\n",
      "-60\n",
      "-59\n",
      "-58\n",
      "-57\n",
      "-56\n",
      "-55\n",
      "-54\n",
      "-53\n",
      "-52\n",
      "-51\n",
      "-50\n",
      "-49\n",
      "-48\n",
      "-47\n",
      "-46\n",
      "-45\n",
      "-44\n",
      "-43\n",
      "-42\n",
      "-41\n",
      "-40\n",
      "-39\n",
      "-38\n",
      "-37\n",
      "-36\n",
      "-35\n",
      "-34\n",
      "-33\n",
      "-32\n",
      "-31\n",
      "-30\n",
      "-29\n",
      "-28\n",
      "-27\n",
      "-26\n",
      "-25\n",
      "-24\n",
      "-23\n",
      "-22\n",
      "-21\n",
      "-20\n",
      "-19\n",
      "-18\n",
      "-17\n",
      "-16\n",
      "-15\n",
      "-14\n",
      "-13\n",
      "-12\n",
      "-11\n",
      "-10\n",
      "-9\n",
      "-8\n",
      "-7\n",
      "-6\n",
      "-5\n",
      "-4\n",
      "-3\n",
      "-2\n",
      "-1\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "count = -300\n",
    "while count<10:\n",
    "    print(count)\n",
    "    count+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "210f4369",
   "metadata": {},
   "source": [
    "functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "8fe83e62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 100\n"
     ]
    }
   ],
   "source": [
    "# function name\n",
    "# inputs (arguments, parameters)\n",
    "# outputs (return)\n",
    "\n",
    "def my_quadratic_function(x):\n",
    "    return x**2\n",
    "\n",
    "t = 5**2\n",
    "s = my_quadratic_function(10)\n",
    "print(t, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "926b678e",
   "metadata": {},
   "source": [
    "## Import Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "be7e21fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "bee8a102",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6502878401571168"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c60d4b31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32c406ee",
   "metadata": {},
   "source": [
    "# Algorithms Notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "51bc40e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# input --> algorithm --> output\n",
    "# even / odd algorithm\n",
    "\n",
    "# log(n) squared algorithm O(log(n)^2)\n",
    "def even_odd(number):\n",
    "    return number % 2 == 0\n",
    "\n",
    "# constant time algorithm O(1)\n",
    "def even_odd_str(number):\n",
    "    last_number = number[-1]\n",
    "    return last_number in [0, 2, 4, 6, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4ae1a48e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.302585092994046\n",
      "6.907755278982137\n"
     ]
    }
   ],
   "source": [
    "print(np.log(10))\n",
    "print(np.log(1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "2b3fd355",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0706\n"
     ]
    }
   ],
   "source": [
    "# guess my PIN\n",
    "secret_pin = '0706'\n",
    "\n",
    "for i in range(10):\n",
    "    for j in range(10):\n",
    "        for k in range(10):\n",
    "            for l in range(10):\n",
    "                guess = str(i)+str(j)+str(k)+str(l)\n",
    "                if guess==secret_pin:\n",
    "                    print(guess)\n",
    "                    \n",
    "# exponential time algorithm\n",
    "# O(10^m), where m is the length of the pin"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0fc105d",
   "metadata": {},
   "source": [
    "# Binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "c78885d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's count in base 10\n",
    "# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,.. 10, 11, 12, 13, 14, 15, 16\n",
    "\n",
    "# let's count in base 5\n",
    "# 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, \n",
    "# 20, 21, 22, 23, 24, 30, 31, 32, 33, 34\n",
    "# 40, 41, 42, 43, 44, 100, \n",
    "\n",
    "# let's count in base 2\n",
    "# 0, 1, 10, 11, 100, 101, 110\n",
    "\n",
    "# convert 0 from base 2 into base 10\n",
    "0*(2**0)\n",
    "\n",
    "# convert 1 from base 2 into base 10\n",
    "1*(2**0)\n",
    "\n",
    "# convert 10110 from base 2 into base 10\n",
    "0*(2**0) + 1*(2**1) + 1*(2**2) + 0*(2**3) + 1*(2**4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "591759af",
   "metadata": {},
   "source": [
    "binary is the building block of classical computers, because they encode information using either 'on' (1) or 'off' (0) using a **bit**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f322c1d8",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}