2020-03-16_biof309.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split a cell at the cursor: ctrl shift -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two types of arguments:\n",
    "# 1. Positional\n",
    "# 2. Keyword (named)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- All positional args must be passed first\n",
    "- In other words, positional arguments cannot follow keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello my name is Martin\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    # Positional\n",
    "    \"hello\", \"my\", \"name\", \"is\", \"Martin\",\n",
    "    # Keyword\n",
    "#     sep=\"\\n\", end=\"!\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ternary operator (conditional expression)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'truthy'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_seq = []\n",
    "# ternary operator (conditional expression)\n",
    "# part 1     part 2    part 3\n",
    "# if true, condition, if false\n",
    "\"truthy\" if input_seq else \"falsy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### None\n",
    "- None is falsy (consider to be False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequences (strings, lists, sets, tuples, dictionaries):\n",
    "- non-empty sequences are truthy (consider to be True)\n",
    "- empty sequences are falsy (consider to be False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numbers (int, float):\n",
    "- non-zero numbers are truthy (consider to be True)\n",
    "- zero is falsy (consider to be False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input_list is None\n"
     ]
    }
   ],
   "source": [
    "input_list = None\n",
    "if len(input_list) == 0:\n",
    "    print(\"input_list is not empty\")\n",
    "# Specific (input_list must be None)\n",
    "if input_list is None:\n",
    "    print(\"input_list is None\")\n",
    "# Non=Specific (input_list must falsy)\n",
    "elif not input_list:\n",
    "    print(\"input_list is empty\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "typing._SpecialForm"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Optional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import complex types from typing module\n",
    "from typing import Optional, List\n",
    "\n",
    "# Set default argument to None\n",
    "def get_non_empty(x=None):\n",
    "    \"\"\"Return the input unless the input is zero, empty, or None.\"\"\"\n",
    "    if x:\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_non_empty((1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_list(list(\"abc\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input_list is None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(get_list())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input_list is None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(get_list(None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Callables:\n",
    "- Classes\n",
    "- Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two types of functions:\n",
    "# 1. Global\n",
    "# 2. Method\n",
    "\n",
    "# 1. Global\n",
    "sum(range(9))\n",
    "min(range(9))\n",
    "max(range(9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "import builtins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a b c\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a b c'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2. Method\n",
    "\" \".join(\"a b c\".split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "x = 9\n",
    "# Conditional expression (ternary operator)\n",
    "(\n",
    "    \"hi\"\n",
    "    if x > 8\n",
    "    else \"mid\"\n",
    "    if x > 4\n",
    "    else \"lo\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "# Conditional statement\n",
    "if x > 8:\n",
    "    print(\"hi\")\n",
    "elif x > 4:\n",
    "    print(\"mid\")\n",
    "else:\n",
    "    print(\"lo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Three uses of the if keyword:\n",
    "- conditional expression (ternary operator)\n",
    "- conditional statement (if statement)\n",
    "- if clause (inside a comprehension)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parts of a list comprehension:\n",
    "1. expression (what you want)\n",
    "2. for clause (for `var` in `iterable`)\n",
    "    - need at least one\n",
    "    - can have as many as you want\n",
    "    - each for clause, can be followed by\n",
    "    - an unlimited number of if clauses\n",
    "3. if clause (if `condition`)\n",
    "    - optional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[25, 49, 81]"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_odd_squares = [\n",
    "    # what you want\n",
    "    x**2\n",
    "    # how you iterate to get it (for clause)\n",
    "    for x in range(10)\n",
    "    # how you remove what you don't want (if clause)\n",
    "    if x**2 > 10\n",
    "    and x**2 % 2 != 0\n",
    "    ]\n",
    "large_odd_squares "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use list comprehensions instead of map (a builtin function)\n",
    "large_even_squares_or_small_even_numbers = [\n",
    "    # what you want (can use ternary operator)\n",
    "    x**2 if x > 4 else x\n",
    "    # how you iterate to get it\n",
    "    for x in range(9)\n",
    "    # how you remove what you don't want\n",
    "    if x**2 % 2 == 0\n",
    "]\n",
    "large_squares_or_just_the_numbers\n",
    "\n",
    "# Use a list comprehension inside a function\n",
    "def sum_small_even_squares(start, stop, maximum):\n",
    "    return sum(\n",
    "        x**2\n",
    "        for x in range(start, stop)\n",
    "        if x**2 < maximum\n",
    "        and x**2 % 2 == 0\n",
    "    )\n",
    "\n",
    "# Use an assignment expression (python >= 3.8 only),\n",
    "# also known as the walrus operator,\n",
    "# to avoid calculating x**2 three times\n",
    "def sum_small_even_squares(start, stop, maximum):\n",
    "    return sum(\n",
    "        square\n",
    "        for x in range(start, stop)\n",
    "        if (square := x**2) < maximum\n",
    "        and square % 2 == 0\n",
    "    )\n",
    "\n",
    "sum_small_even_squares(0, 9, 20)\n",
    "\n",
    "# args\n",
    "def multiply(*args):\n",
    "    product = 1\n",
    "    for num in args:\n",
    "        product *= num\n",
    "    print(product)\n",
    "\n",
    "multiply(4, 5, 6) # Prints 120!\n",
    "\n",
    "# You can do the same with np.prod\n",
    "import numpy as np\n",
    "np.prod(4, 5, 6)\n",
    "# or with math.prod (python >= 3.8 only)\n",
    "import math\n",
    "math.prod(4, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.8.1\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting package metadata (current_repodata.json): done\n",
      "Solving environment: done\n",
      "\n",
      "## Package Plan ##\n",
      "\n",
      "  environment location: /Users/skarzynskimw/miniconda/envs/py\n",
      "\n",
      "  added / updated specs:\n",
      "    - numpy\n",
      "\n",
      "\n",
      "The following packages will be downloaded:\n",
      "\n",
      "    package                    |            build\n",
      "    ---------------------------|-----------------\n",
      "    certifi-2019.11.28         |   py38h32f6830_1         149 KB  conda-forge\n",
      "    libblas-3.8.0              |      16_openblas          10 KB  conda-forge\n",
      "    libcblas-3.8.0             |      16_openblas          10 KB  conda-forge\n",
      "    liblapack-3.8.0            |      16_openblas          10 KB  conda-forge\n",
      "    libopenblas-0.3.9          |       h3d69b6c_0         8.4 MB  conda-forge\n",
      "    numpy-1.18.1               |   py38hde6bac1_0         5.1 MB  conda-forge\n",
      "    python_abi-3.8             |           1_cp38           4 KB  conda-forge\n",
      "    ------------------------------------------------------------\n",
      "                                           Total:        13.6 MB\n",
      "\n",
      "The following NEW packages will be INSTALLED:\n",
      "\n",
      "  libblas            conda-forge/osx-64::libblas-3.8.0-16_openblas\n",
      "  libcblas           conda-forge/osx-64::libcblas-3.8.0-16_openblas\n",
      "  libgfortran        conda-forge/osx-64::libgfortran-4.0.0-2\n",
      "  liblapack          conda-forge/osx-64::liblapack-3.8.0-16_openblas\n",
      "  libopenblas        conda-forge/osx-64::libopenblas-0.3.9-h3d69b6c_0\n",
      "  llvm-openmp        conda-forge/osx-64::llvm-openmp-9.0.1-h28b9765_2\n",
      "  numpy              conda-forge/osx-64::numpy-1.18.1-py38hde6bac1_0\n",
      "  python_abi         conda-forge/osx-64::python_abi-3.8-1_cp38\n",
      "\n",
      "The following packages will be UPDATED:\n",
      "\n",
      "  certifi              pkgs/main::certifi-2019.11.28-py38_0 --> conda-forge::certifi-2019.11.28-py38h32f6830_1\n",
      "\n",
      "The following packages will be SUPERSEDED by a higher-priority channel:\n",
      "\n",
      "  ca-certificates     pkgs/main::ca-certificates-2020.1.1-0 --> conda-forge::ca-certificates-2019.11.28-hecc5488_0\n",
      "  openssl              pkgs/main::openssl-1.1.1d-h1de35cc_4 --> conda-forge::openssl-1.1.1d-h0b31af3_0\n",
      "\n",
      "\n",
      "\n",
      "Downloading and Extracting Packages\n",
      "libcblas-3.8.0       | 10 KB     | ##################################### | 100% \n",
      "libblas-3.8.0        | 10 KB     | ##################################### | 100% \n",
      "liblapack-3.8.0      | 10 KB     | ##################################### | 100% \n",
      "certifi-2019.11.28   | 149 KB    | ##################################### | 100% \n",
      "numpy-1.18.1         | 5.1 MB    | ##################################### | 100% \n",
      "python_abi-3.8       | 4 KB      | ##################################### | 100% \n",
      "libopenblas-0.3.9    | 8.4 MB    | ##################################### | 100% \n",
      "Preparing transaction: done\n",
      "Verifying transaction: done\n",
      "Executing transaction: done\n"
     ]
    }
   ],
   "source": [
    "!conda install -yc conda-forge numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def abs_mult(*args, absolute=True):\n",
    "    product = np.prod(args)\n",
    "    return abs(product) if absolute else product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "list0 = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beeps = 2\n",
    "boops = 6\n",
    "total = beeps + boops\n",
    "print(total) # prints 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.7.2\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting package metadata (current_repodata.json): done\n",
      "Solving environment: failed with initial frozen solve. Retrying with flexible solve.\n",
      "Solving environment: failed with repodata from current_repodata.json, will retry with next repodata source.\n",
      "Collecting package metadata (repodata.json): done\n",
      "Solving environment: failed with initial frozen solve. Retrying with flexible solve.\n",
      "Solving environment: | \n",
      "Found conflicts! Looking for incompatible packages.\n",
      "This can take several minutes.  Press CTRL-C to abort.\n",
      "| "
     ]
    }
   ],
   "source": [
    "!conda install -yc conda-forge python=3.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-ebceedf252c9>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-ebceedf252c9>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    square := x**2\u001b[0m\n\u001b[0m           ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def sum_small_even_squares(start, stop, maximum):\n",
    "    return sum(\n",
    "        square := x**2\n",
    "        for x in range(start, stop)\n",
    "        if square < threshold\n",
    "        and square % 2 == 0\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.7.2\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(math)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "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": 4
}