python_lecture1_the_phantom_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "08e91868-83d8-4659-bd5a-4c7b51cf57ea",
   "metadata": {},
   "source": [
    "# This is a markdown cell\n",
    "\n",
    "## You can use it to document your experimental code.\n",
    "\n",
    "It's like having a word processor *inside* of your **notebook**.\n",
    "\n",
    "![Grace Hopper](https://upload.wikimedia.org/wikipedia/commons/thumb/a/ad/Commodore_Grace_M._Hopper%2C_USN_%28covered%29.jpg/1024px-Commodore_Grace_M._Hopper%2C_USN_%28covered%29.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "583275e6-0bc9-4d81-9a1e-0db057180bf6",
   "metadata": {},
   "source": [
    "- First *item*\n",
    "- Second **item**\n",
    "- Third item\n",
    "    - Indented ***item***\n",
    "    - Indented item\n",
    "- Fourth item"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18df4dd4-e122-4282-a054-eddc6d9caffe",
   "metadata": {},
   "source": [
    "## All the Math you want to write in the markdown should be inside opening and closing \\$ symbol in order to be processed as Math.\n",
    "\n",
    "$\\beta$ : \\beta  Creates the symbol beta\n",
    "\n",
    "$\\hat{Y}$ : \\$\\hat{Y}\\$ A hat is covered over anything inside the curly braces of \\hat{}. E.g. in \\hat{Y} hat is created over Y and in \n",
    "\n",
    "$\\hat{\\beta}_{0}$,  \\hat{\\beta}_{0}  hat is shown over beta\n",
    "\n",
    "$\\hat{\\beta}_{0} $: \\hat{\\beta}_{0} Creates as subscript, anything inside the curly braces after _. E.g. \\hat{\\beta}_{0} will create beta with a hat and give it a subscript of 0.\n",
    "\n",
    "$^{} $ : ^{} (Similar to subscript) Creates as superscript, anything inside the curly braces after ^.\n",
    "\n",
    "$\\sum $: \\sum  Creates the summation symbol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f30bf7e9-f2c4-4344-9f2d-1ee65be44632",
   "metadata": {},
   "source": [
    "Inline equations $$\\gamma_{jm} = \\underset{\\gamma}{\\textrm{arg min}} \\sum \\limits _{x_{i} \\in R_{jm}} L(y_{i}, f_{m−1}(x_{i}) + \\gamma)$$ are cool"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ac007d1-7fd2-4ce3-a871-04bddee5f6fb",
   "metadata": {},
   "source": [
    "## Tables\n",
    "\n",
    "https://www.tablesgenerator.com/markdown_tables\n",
    "\n",
    "| Col 1 | Col 2 | Reaction | Dosage | Concentration |\n",
    "|-------|-------|----------|--------|---------------|\n",
    "| 1     | 0     | A2       | Hello  | X1            |\n",
    "| 2     | 2     | 2        | 3      | -4            |\n",
    "| A     | B     | C        | D      | E             |\n",
    "| 10    | 20    | 30       | 40     | 55            |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfbf0b2e-4468-48ce-9853-c61d5dc6ab59",
   "metadata": {},
   "source": [
    "Many more [markdown tips](https://www.markdownguide.org/basic-syntax/) are here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d9dae4c-1be9-4b0e-ac77-f70b6db91976",
   "metadata": {},
   "source": [
    "## Integers and Floats\n",
    "\n",
    "Floats have a decimal point. Integers don't have a decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b47c8a5e-f317-4273-b1d0-8b0f405cefcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "396b26dc-fa17-47ec-aa1b-c620ba1b0bdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(x)) # Prints \"<class 'int'>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "64eb9705-c95d-4f7e-84e3-ca4edb550f98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "2\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(x)       # Prints \"3\"\n",
    "print(x + 1)   # Addition; prints \"4\"\n",
    "print(f'{x - 1}')   # Subtraction; prints \"2\"\n",
    "print(x * 2)   # Multiplication; prints \"6\"\n",
    "print(x ** 2)  # Exponentiation; prints \"9\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a3ce5dca-a395-4a61-a9fc-1e4392603cb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now the number is 4 because of the +=\n"
     ]
    }
   ],
   "source": [
    "x += 1\n",
    "print(f'Now the number is {x} because of the +=')  # Prints \"4\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4e211c13-b297-4cc8-a77f-913498f7a83b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now we're at 8 because of the *=\n"
     ]
    }
   ],
   "source": [
    "x *= 2\n",
    "print(f'Now we\\'re at {x} because of the *=')  # Prints \"8\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "375c9846-0330-4fbb-ad2c-0e0e27eb4aa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "y = 2.5\n",
    "print(type(y)) # Prints \"<class 'float'>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "52ba7402-e5bf-4527-afa9-caa7d28c00cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We can do inline calculations 2.5, 3.5000, 5.000000, 6.25\n"
     ]
    }
   ],
   "source": [
    "print(f'We can do inline calculations {y}, {y + 1:.4f}, {y * 2:.6f}, {y ** 2}') # Prints \"2.5 3.5000 5.000000 6.25\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bda2f765-eddb-4b1b-9122-fcd19a5d4377",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.028\n"
     ]
    }
   ],
   "source": [
    "y = 6\n",
    "z = x*3 + y**-2 - 3\n",
    "print(f'{z:.3f}')  # Prints 21.028"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0930cae8-181b-4cfe-b035-447747a1bc3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label #ABC0008\n",
      "Label #ABC0208\n",
      "Label #ABC1008\n"
     ]
    }
   ],
   "source": [
    "print(f'Label #ABC{x:04d}')\n",
    "print(f'Label #ABC{x+200:04d}')\n",
    "print(f'Label #ABC{x+1000:04d}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42040c72-b937-4e36-b006-23a147968311",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "953d1a98-6ffd-4587-83ab-80ef7a4958bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "print(type(t)) # Prints \"<class 'bool'>\"\n",
    "print(t and f) # Logical AND; prints \"False\"\n",
    "print(t or f)  # Logical OR; prints \"True\"\n",
    "print(not t)   # Logical NOT; prints \"False\"\n",
    "print(t != f)  # Logical XOR; prints \"True\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31ab6f20-8fc5-42f3-8346-1ce3b550b010",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8dc3044d-557a-4502-b3e8-3d2c8733cba3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "5\n",
      "hello world\n"
     ]
    }
   ],
   "source": [
    "hello = 'hello'    # String literals can use single quotes\n",
    "world = \"world\"    # or double quotes; it does not matter.\n",
    "print(hello)       # Prints \"hello\"\n",
    "print(len(hello))  # String length; prints \"5\"\n",
    "hw = hello + ' ' + world  # String concatenation\n",
    "print(hw)  # prints \"hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "753b19aa-78a4-4923-8c69-2211e1b345d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ATCG ATCG ATCG ATCG ATCG ATCG ATCG \n"
     ]
    }
   ],
   "source": [
    "print('ATCG '*7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "61505bc9-b680-4243-8bb4-44888c5413c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "  hello\n",
      " hello \n",
      "he(ell)(ell)o\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print(s.capitalize())  # Capitalize a string; prints \"Hello\"\n",
    "print(s.upper())       # Convert a string to uppercase; prints \"HELLO\"\n",
    "print(s.rjust(7))      # Right-justify a string, padding with spaces; prints \"  hello\"\n",
    "print(s.center(7))     # Center a string, padding with spaces; prints \" hello \"\n",
    "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another;\n",
    "                                # prints \"he(ell)(ell)o\"\n",
    "print('  world '.strip())  # Strip leading and trailing whitespace; prints \"world\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97888925-1317-4529-89bd-e28b9c524dc9",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "eabe0225-0efd-4e9d-97a0-44ba0f604a28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 5, -3, 5]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "b = [1,3,4,5,-3,5]\n",
    "print(b)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6043cfb9-f684-4799-a960-3beb3176208e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 5, -3, 5, 1, 102]\n",
      "[3, 4]\n",
      "[3, -3]\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "b += [1, 102]\n",
    "print(b)\n",
    "print(b[1:3])\n",
    "print(b[1:7:3])\n",
    "print(b[-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "70abc35d-2e5a-4a1b-b5b5-e3f1e4984ec9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', 'b'], ['f', 'g']]\n"
     ]
    }
   ],
   "source": [
    "c = [['a', 'b'], ['f', 'g']]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "04deca36-3889-4ce5-9f8c-524f5b9e2fd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 8, 9, 4]\n"
     ]
    }
   ],
   "source": [
    "nums = list(range(5))     # range is a built-in function that creates a list of integers\n",
    "print(nums)               # Prints \"[0, 1, 2, 3, 4]\"\n",
    "print(nums[2:4])          # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
    "print(nums[2:])           # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
    "print(nums[:2])           # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
    "print(nums[:])            # Get a slice of the whole list; prints \"[0, 1, 2, 3, 4]\"\n",
    "print(nums[:-1])          # Slice indices can be negative; prints \"[0, 1, 2, 3]\"\n",
    "nums[2:4] = [8, 9]        # Assign a new sublist to a slice\n",
    "print(nums)               # Prints \"[0, 1, 8, 9, 4]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "640206fa-b041-43b2-b321-576a8ce64da4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-13, -10, -7, -4, -1, 2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53]\n"
     ]
    }
   ],
   "source": [
    "nums = list(range(-13,55,3))     # range is a built-in function that creates a list of integers\n",
    "print(nums)               "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "677e3d77-baab-41e3-9156-eb24df04d2ab",
   "metadata": {},
   "source": [
    "## For loops and lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3555e414-ef35-4454-8bb6-569b441b0311",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "monkey\n",
      "\n",
      "cat4dog4monkey4"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for animal in animals:\n",
    "    print(animal)\n",
    "    \n",
    "print()\n",
    "\n",
    "for animal in animals:\n",
    "    print(animal, end='4')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "109c56de-4cac-4c99-90f0-5193be785066",
   "metadata": {},
   "source": [
    "## Dictionaries and Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5bf9a834-3c7f-4fb8-b37b-e87c2ef72c37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A person has 2 legs.\n",
      "\n",
      "\n",
      "A cat has 4 legs.\n",
      "\n",
      "\n",
      "A spider has 8 legs.\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal_type in d:\n",
    "    num_legs = d[animal_type]\n",
    "    print(f'A {animal_type} has {num_legs} legs.\\n\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d70b5124-b70e-4e73-aea0-ed826f83d53c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#3: A person has 2 legs.\n",
      "#4: A cat has 4 legs.\n",
      "#5: A spider has 8 legs.\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for idx, animal_type in enumerate(d):\n",
    "    num_legs = d[animal_type]\n",
    "    print(f'#{idx+3}: A {animal_type} has {num_legs} legs.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61c2f1c6-5555-4430-b8d7-90e3b1601fc1",
   "metadata": {},
   "source": [
    "## Functions and If-Then"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5758528b-80ae-4e2f-bcaf-0b9e2ac9f321",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative\n",
      "zero\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "def sign_me(x):\n",
    "    \"\"\"\n",
    "    This is a function\n",
    "    \"\"\"\n",
    "    if x > 0:\n",
    "        return 'positive'  # Returns positive\n",
    "    elif x < 0:\n",
    "        return 'negative'  # Returns negative\n",
    "    else:\n",
    "        return 'zero'      # Returns zero\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sign_me(x))\n",
    "# Prints \"negative\", \"zero\", \"positive\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c5ad3e96-743f-40f7-a80d-80a692e48f04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Molly\n",
      "Hello, Molly\n",
      "Hello, Molly\n",
      "HELLO, AUDREY!\n",
      "Hello, Rich\n",
      "Hello, Rich\n",
      "Hello, Rich\n",
      "Hello, Rich\n",
      "Hello, Rich\n"
     ]
    }
   ],
   "source": [
    "def say_hello(name, loud=False, times=1):\n",
    "    for _ in range(times):\n",
    "        if loud:\n",
    "            print(f'HELLO, {name.upper()}!')\n",
    "        else:\n",
    "            print(f'Hello, {name}')\n",
    "\n",
    "say_hello('Molly', times=3) # Prints \"Hello, Molly 3 times\"\n",
    "say_hello('Audrey', loud=True)  # Prints \"HELLO, AUDREY!\"\n",
    "say_hello('Rich', loud=False, times=5)  # Prints \"HELLO, RICH!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3b647a86-e8fd-4ee9-975a-f2091324ca1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Fred\n",
      "HELLO, FRED!\n",
      "Hello, Resilience\n",
      "Hello, Resilience\n",
      "Hello, Resilience\n",
      "Name length is 10\n"
     ]
    }
   ],
   "source": [
    "class Greeter(object):\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Create an instance variable\n",
    "\n",
    "    # Instance method\n",
    "    def greet(self, loud=False, times=1):\n",
    "        for _ in range(times):\n",
    "            if loud:\n",
    "                print(f'HELLO, {self.name.upper()}!')\n",
    "            else:\n",
    "                print(f'Hello, {self.name}')\n",
    "                \n",
    "                \n",
    "    def name_length(self):\n",
    "        return len(self.name)\n",
    "\n",
    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED!\"\n",
    "g.name_length()\n",
    "\n",
    "h = Greeter('Resilience')\n",
    "h.greet(times=3, loud=False)\n",
    "print(f'Name length is {h.name_length()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6966c6b-e8c0-400f-85e8-d913f831a979",
   "metadata": {},
   "source": [
    "## Input from keyboard\n",
    "\n",
    "Input is assumed to be a string, but we can always turn it into a float or int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f8631289-38dd-4cac-bdc3-9162ed0b0ca6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  tony\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, tony\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name again:  tony\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, tony\n",
      "Hello, tony\n",
      "Hello, tony\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  3\n",
      "Now enter another number:  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d + e = 10.0\n"
     ]
    }
   ],
   "source": [
    "m = input('Enter your name: ')\n",
    "h = Greeter(m)\n",
    "h.greet()\n",
    "\n",
    "\"\"\"\n",
    "Note how we can in-line everything to create a single instruction\n",
    "\"\"\"\n",
    "j = Greeter(input('Enter your name again: ')).greet(times=3, loud=False)\n",
    "\n",
    "\n",
    "d = int(input('Enter a number: '))\n",
    "e = float(input('Now enter another number: '))\n",
    "\n",
    "print(f'd + e = {d + e}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34fcafcd-9b2b-442d-ae7c-e1d4648e75db",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}