IntroPython1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z-3tCgr7jIxq"
   },
   "source": [
    "# Getting Setup\n",
    "- Select intropython kernel for this Python notebook (top right corner)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QNesIkEEfAya"
   },
   "source": [
    "\n",
    "\n",
    "# Numbers\n",
    "\n",
    "Python can perform mathematical operations, something you will likely use if you work with data in Python. There are different types of numbers -- integers are whole numbers (no decimals) that can be either positive or negative. Floats are numbers with decimals. Python also has complex numbers but we will not cover that here. Python arithmetic operations follow the order of operations -- PEMDAS (parentheses, exponents, division, addition, subtraction)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OwDCFcimeNJR"
   },
   "source": [
    "## Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GPiyfm_XguSe",
    "outputId": "6314214c-ca9e-4505-9cb9-a1b7147c74fd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0+10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Iz6HTC_jfAyc",
    "outputId": "4d729e04-3189-4ed8-8729-16abbf3b4504"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Za9ZTQ5ieqLB"
   },
   "source": [
    "### Checking Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TAxoIWRkehcW",
    "outputId": "639a784a-cf1c-4b90-9d65-1bc181e3c3de"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2+10) # this is a comment. type(...) tells us the type of number inside the parentheses, here 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uxuNpUfZg5Zp",
    "outputId": "9e398e01-e010-40fb-fca5-40c86a009ff1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2.0+10)  # mixed types (mixed integers / floats) convert to float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F26AricweZ7f"
   },
   "source": [
    "## Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "R0f4XgTJgwxX",
    "outputId": "599fd316-2a4f-45a5-adc2-d8ad41e89aab"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0*10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_nL3ZkvWfAyd",
    "outputId": "1e2f0b18-19b1-46c3-9b82-f7ab634df1c3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "siS5t4KTed8R"
   },
   "source": [
    "## Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "omPPWZvCfAyd",
    "outputId": "2dd28bbf-4d75-4a5c-daf7-824a95f62ef2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "50 - 5*6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z_N2HO9Ce0lv"
   },
   "source": [
    "## Division\n",
    "\n",
    "Also, note that order of operations holds in python, and you can use parentheses to group operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EZfXTYgVfAyd",
    "outputId": "f6ed4dcf-3430-41e8-fbcf-87e1c5024354"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this is a multiline comment. \n",
    "division always returns a float\n",
    "\"\"\"\n",
    "\n",
    "\"\"\" this\n",
    "is \n",
    "my \n",
    "multiline comment\"\"\"\n",
    "#singleline comment\n",
    "\n",
    "(50 - 5*6)/4 \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1PGtVe3_fKad",
    "outputId": "ba7faef2-d7ca-422a-dfd6-47cff55fec6e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type((50 - 5*6)/4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fNKZgCcCfnQm"
   },
   "source": [
    "### Integer Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Is0TTOt2fAye",
    "outputId": "76e4b656-035e-49f6-ec8b-aadcdcd4099a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5//8 # Integer division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "epa6VHQafrt9",
    "outputId": "8e9fecad-8011-400d-8852-9e6b5311ff70"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5//8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eqykKBuPfyCr"
   },
   "source": [
    "## Modulo\n",
    "Modulo is an operation that you may not be familiar with from your elementary school math classes. Modulo, `a%b`, calculates the remainder of `a` when divided by `b`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TsPYhxQlfAye",
    "outputId": "2ab8464d-82ac-4091-8176-a4f4509dc5ba"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "mW2pAw7_fAye",
    "outputId": "96732769-a3ea-465f-9543-96c384c0adc5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "OOqS5XerfAye",
    "outputId": "7d3b7d43-dd1b-471a-e6ab-be2df69510b3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5*3 + 2#quotient * divisor + remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gf8fzolTJ2N6"
   },
   "source": [
    "### Exercise:\n",
    "\n",
    "What will `7%3` be?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G9IF3FJGfAyh"
   },
   "source": [
    "## Exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "wrPCnNhlfAyh",
    "outputId": "6f7ef13d-9fc0-4574-d6d6-b64d8cbd2944"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**3 # 2 cubed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "lx8VUPdJfAyh",
    "outputId": "bba080be-b751-498a-a463-888dc1237494"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25298221281347033"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.5**(-3/2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "noDz4yC4KZup"
   },
   "source": [
    "## Exercises:\n",
    "For each of the following, what will the output be, and what type will it be?\n",
    "\n",
    "1. `3 + 2/1`\n",
    "2. `3 + 2 //1`\n",
    "3. `3.0 + 2//1`\n",
    "4. `2**2*2/3`\n",
    "5. `5%2 -3`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5%2-3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EXnLVH2_goOo"
   },
   "source": [
    "# Defining Variables\n",
    "\n",
    "Variables let you store values and work with them by name.\n",
    "\n",
    "In python, variables can change types after they are created.\n",
    "\n",
    "> Rules for Python variables:\n",
    "- A variable name must start with a letter or the underscore character\n",
    "- A variable name cannot start with a number\n",
    "- A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )\n",
    "- Variable names are case-sensitive (age, Age and AGE are three different variables)\n",
    "- In Python, typically use snake case (separate words by underscores)\n",
    "\n",
    "(Taken from https://www.w3schools.com/python/gloss_python_variable_names.asp)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "pJ7GX4SqfAyf"
   },
   "outputs": [],
   "source": [
    "number = 17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "N9w34CHbfAyf",
    "outputId": "8e26e693-d310-4246-896d-29b8af6b77a9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "cixQgQRdfAyf",
    "outputId": "07e798d9-89cc-400d-d331-9d6994846ba6"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'quotient' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [27], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mquotient\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'quotient' is not defined"
     ]
    }
   ],
   "source": [
    "quotient # undefined variable returns an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "TgFCcESsfAyf",
    "outputId": "60832344-55a1-4f5b-bb93-be83b94cd171"
   },
   "outputs": [],
   "source": [
    "quotient = 17//3 # how else could we write this?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Could we use `number` to define quotient? Do so below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "OaVmGTuyfAyf",
    "outputId": "f81aba87-246d-47b8-f735-068706be3b34"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "remainder = number%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "eS__S2H5fAyg",
    "outputId": "5e5e9d25-9d29-44bc-e893-deb7d4e51ac4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "uQiG08b8fAyg",
    "outputId": "a5a3b9ca-470f-4284-9929-cd5c20b5d3a1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient *3 +remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rY2qEeajfAyg"
   },
   "source": [
    "# Check for equality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "vC1cdWrEfAyg",
    "outputId": "f86d1f1a-85cd-4b80-ec8b-da6ad7f5987e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 == 17 # 17 is equal to 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "IDZVKEvmfAyg",
    "outputId": "c5ade5f0-f11b-48e9-edf1-af02d3be80b5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17==16 # 17 is equal to 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "NxAyUynefAyg",
    "outputId": "2009467a-2309-48d5-9502-f585d28d0ae5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient*3 + remainder == number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q3ooBMV8LtEp"
   },
   "source": [
    "# Exercise: \n",
    "What will the following blocks of code give?\n",
    "\n",
    " \n",
    "\n",
    "```\n",
    "# Exercise 1\n",
    "a = 22\n",
    "b = 21\n",
    "a == b\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "# Exercise 2\n",
    "a = 22\n",
    "b = 22\n",
    "c = a\n",
    "a == b\n",
    "```\n",
    "\n",
    "\n",
    "```\n",
    "# Exercise 3\n",
    "1a = 1\n",
    "b = 22\n",
    "1a == b\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid decimal literal (80554094.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn [39], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    1a = 1\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
     ]
    }
   ],
   "source": [
    "1a = 1\n",
    "b = 22\n",
    "1a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wO-hlOZffAyh"
   },
   "source": [
    "# Strings\n",
    "\n",
    "Strings are a data type for working with text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "LMmd24sRfAyi",
    "outputId": "33b157cb-4ba3-4fc7-82cb-6155e887b2bb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world string'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hello world string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "xIhndBWlfAyi",
    "outputId": "24d2ff30-3e53-4ea2-df88-5c39449a86ae"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'also a hello world string'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"also a hello world string\" # can use single or double quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "lCB5XGPsfAyi",
    "outputId": "2d8443d3-4e2d-4922-ca73-726d4591230c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"isn't it nice to use double quotes sometimes?\""
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"isn't it nice to use double quotes sometimes?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "kMf-Y3ksfAyi",
    "outputId": "60794ee2-c7cf-4bd2-b509-2b2bd8fb2822"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"it isn't nice to use single quotes sometimes\""
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'it isn\\'t nice to use single quotes sometimes' # can use the escape(\\) character to use a character that would otherwise do something else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "k2aBlFd8fAyi",
    "outputId": "a44c6181-f92d-4de7-b4a9-a5ebf142e8f3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'she said \"single quotes can be nice too\"'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'she said \"single quotes can be nice too\"'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "GNDbIGVrfAyi",
    "outputId": "26f2b7a4-91e6-4486-ec0a-5712b4ce2ee2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'she said \"but it\\'s still doable with double quotes\"'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"she said \\\"but it's still doable with double quotes\\\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JU0kSwsIfAyj"
   },
   "source": [
    "hmm there's a weird character in there. what does it look like if we print it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "udkXeAo8fAyj",
    "outputId": "9d707595-82d6-4898-944a-17246daeb2ee"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "she said \"but it's still doable with double quotes\"\n"
     ]
    }
   ],
   "source": [
    "print(\"she said \\\"but it's still doable with double quotes\\\"\") # ah much better"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gIk25gQJfAyj"
   },
   "source": [
    "## Print\n",
    "\n",
    "Print is something called a function -- we will learn more about functions next time. Functions take 0 or more inputs and runs some code.\n",
    "\n",
    "### Help\n",
    "\n",
    "Use help to find out what a function does (sometimes hovering won't work). You can also google the function to find out what it does. The description of what a function does is called a \"docstring.\" We will learn more about docstrings when we learn about functions next class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zIdmSS7LfAyk",
    "outputId": "98e009bf-cb2a-460d-d77a-b3eddfe928bc"
   },
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0H7d6HZTqZdB"
   },
   "source": [
    "In jupyter, you can also use `print?`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "auSNcPpEqXyY"
   },
   "outputs": [],
   "source": [
    "# docstring\n",
    "print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IhSHfO-xV1d0"
   },
   "outputs": [],
   "source": [
    "# with non built in functions, will show the code for the function\n",
    "print??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "O5VPQhkgfAyk",
    "outputId": "7a705dd3-1adb-4349-c440-c450e53a8461"
   },
   "outputs": [],
   "source": [
    "print(\"to include a slash \\\\\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ypL2Yzy4fAyk",
    "outputId": "d44dd686-40a5-42db-bc8f-65ffbd0da39a"
   },
   "outputs": [],
   "source": [
    "print(\"path\\to\\name\") # what happened? How would you fix this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TFvOwDFbmrXA"
   },
   "source": [
    "## Raw Strings\n",
    "\n",
    "Raw strings take characters as they are and slash is not treated as an escape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JNQ0w7DdfAyk",
    "outputId": "088d87e4-ff78-4f54-92e8-ac9115902d32"
   },
   "outputs": [],
   "source": [
    "print(r\"path\\to\\name\") # make it a raw string, what else could we do (see above on including a slash)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KCAezbLTmk8G"
   },
   "source": [
    "## [Optional / At Home] Multiline Strings\n",
    "\n",
    "You can define strings that have multiple lines by enclosing them in triple quotes as `'''string'''` or `\"\"\"string\"\"\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "755X1c79fAyl",
    "outputId": "18982532-2ba6-4503-d69a-9d950149e190"
   },
   "outputs": [],
   "source": [
    "print(\"start\")\n",
    "# without slash adds a new line at start, with escapes the newline\n",
    "print(\"\"\"\n",
    "woah\n",
    "I \n",
    "have \\\n",
    "many lines\"\"\")\n",
    "print(\"\"\"\\\n",
    "woah\n",
    "I \n",
    "have \\\n",
    "many lines\n",
    "\"\"\")\n",
    "print(\"end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TTbduOe0fAyl"
   },
   "source": [
    "## string concatenation & multiplication\n",
    "\n",
    "You can repeat strings by multiplying them by the number of repeats you want, and you can concatenate strings using the addition symbol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 37
    },
    "id": "H1orxoTqfAyl",
    "outputId": "6a278d3a-7fc3-4b19-8b62-d2a0c81abc4e"
   },
   "outputs": [],
   "source": [
    "\"neuro\"*3 + \"science\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cn3xjgN-njEP"
   },
   "source": [
    "## Indexing\n",
    "You can extract individual characters from a string by *indexing* into the string. In Python, indexing starts from 0, so `word[0]` gives the first character in the string `word`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "id": "fBo_xDwFfAym",
    "outputId": "8e398921-57b6-4083-c2a7-6d51d9e25140"
   },
   "outputs": [],
   "source": [
    "word='neuro'\n",
    "print(word)\n",
    "word[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vWARP8kvfAym",
    "outputId": "29a4ac56-ab4a-4cae-c5ce-65ee84ec3ef9"
   },
   "outputs": [],
   "source": [
    "word[5] # because we start from 0 and there are 5 letters in word, 5 is out of range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OmkoAMS1fAym",
    "outputId": "1625ed5b-3f70-45e7-d0f9-7ae0671067c8"
   },
   "outputs": [],
   "source": [
    "len(word) # get the length of word. There are five characters in the string word -- n, e, u, r, and o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mbIrkKK6fAyn",
    "outputId": "92f3d70d-39ab-43b6-c974-ff521d46468b"
   },
   "outputs": [],
   "source": [
    "word[4] # what will this give us?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ozlBzv7ffAyn",
    "outputId": "4ce9c467-991f-437e-d5f9-0e11419990d1"
   },
   "outputs": [],
   "source": [
    "word[-1] # we can get the last character by using -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "05MQbYwMfAyn",
    "outputId": "5b9c5c41-3963-4f96-b91f-300a432812ff"
   },
   "outputs": [],
   "source": [
    "word[-2] # second from last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QvvGcLMKfAyo",
    "outputId": "8a8207cb-0655-4eee-cb5d-b76d589b1cd8"
   },
   "outputs": [],
   "source": [
    "word[-6] # sixth from last"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ATy2d-6pfAyp"
   },
   "source": [
    "## Strings are Immutable\n",
    "\n",
    "This means that you cannot the value of an element in the string, so for example, `word[0]='N'` will not work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 164
    },
    "id": "hFIPfLzRfAyp",
    "outputId": "faf0d95f-3aeb-42ae-ed41-639ea0a48e84"
   },
   "outputs": [],
   "source": [
    "word[0] = 'N'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Uj5F0zw4NYJY"
   },
   "source": [
    "## Exercise\n",
    "\n",
    "What will the following print statements print?\n",
    "\n",
    "```\n",
    "exercise_word = \"foo\\\\\"\n",
    "\n",
    "\n",
    "print(exercise_word) #1\n",
    "print(len(exercise_word)) #2\n",
    "print(exercise_word[1]) #3\n",
    "print(exercise_word[5]) #4\n",
    "print(exercise_word[-1]) #5\n",
    "print(exercise_word*3 + \"bar\") #6\n",
    "exercise_word[-1] = ''\n",
    "print(exercise_word) #7\n",
    "exercise_word = \"new exercise word\"\n",
    "print(exercise_word) #8\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "orNfcUUSfRUf"
   },
   "source": [
    "# Bools\n",
    "\n",
    "Python's bool datatype stores l logical values of `True` or `False`. Bools are named for Boolean logic which specifies operations that can be done between `True` and `False` values, specifically `and`, `or`, and `not`. The rules for boolean logic are listed below: \n",
    "\n",
    "| A | B | A and B | A or B | not A |\n",
    "|---|---|---------|--------|-------|\n",
    "| T | T | T       | T      | F     |\n",
    "| T | F | F       | T      | F     |\n",
    "| F | T | F       | T      | T     |\n",
    "| F | F | F       | F      | T     |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pDN3woR_fAyt",
    "outputId": "384d190b-c4a3-446c-b69d-c6d2c7282df2"
   },
   "outputs": [],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v9766Oc_fAyt",
    "outputId": "2152deae-6399-43c7-86d4-923d6c31e679"
   },
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ypeNHyZ9fAyt",
    "outputId": "4e397fbb-e98a-4692-d52f-c6782827de76"
   },
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_Usdl5rjfAyu",
    "outputId": "b16568ef-55c4-42b9-a309-97b5204368a9"
   },
   "outputs": [],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sfDldMQrfAyu",
    "outputId": "ea72c8a9-fff1-4021-8012-9a3cb11f5f9d"
   },
   "outputs": [],
   "source": [
    "True or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "l84mWfBZfAyu",
    "outputId": "cffb4462-8bee-4d9c-d123-9570a122dbcb"
   },
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order of operations: \n",
    "\n",
    "`not` first, then `and`, then `or`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or (not True) and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(True or (not True)) and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_gGKkY4HfAyt"
   },
   "source": [
    "## Comparison operations\n",
    "Comparison operations let us define booleans from other datatypes based on the values of those datatypes.\n",
    "* less than or equal `<=` \n",
    "* less than `<`\n",
    "* greater than or equal `>=` \n",
    "* greater than `>` \n",
    "* not equal `!=`\n",
    "* is equal to `==`\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ofQOeO1wfAyt",
    "outputId": "c2f50870-5b0c-41ab-b3a9-4f1f43e3f051"
   },
   "outputs": [],
   "source": [
    "print(8<10)\n",
    "print(10 < 10)\n",
    "print(10 <= 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D2140vdifAyu",
    "outputId": "56d6b48c-4700-4241-c4df-32d1bd897dd9"
   },
   "outputs": [],
   "source": [
    "neuroscience ='fun'\n",
    "python = 'fun'\n",
    "\n",
    "# What will this print?\n",
    "print(neuroscience == 'fun' and python == 'fun') \n",
    "print(neuroscience == 'fun' or python == 'fun')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "B-reddoXfAyu",
    "outputId": "1a61239e-92b5-4d71-9712-49f6d5287200"
   },
   "outputs": [],
   "source": [
    "neuroscience ='fun'\n",
    "python = 'cool'\n",
    "\n",
    "# What will this print?\n",
    "print(neuroscience == 'fun' and python == 'fun')\n",
    "print(neuroscience == 'fun' or python == 'fun')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neuroscience ='funny'\n",
    "python = 'cool'\n",
    "\n",
    "# What will this print?\n",
    "print(neuroscience == 'fun' and python == 'fun')\n",
    "print(neuroscience == 'fun' or python == 'fun')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5 # What will this print?\n",
    "print(x < 10 and x > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10 # What will this print?\n",
    "print(x < 10 and x > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0 # What will this print?\n",
    "print(x < 10 and x > 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "\n",
    "Write code like in the above examples that prints `True` if a variable, `y`, is greater than 10 or less than -10, and `False` otherwise.\n",
    "\n",
    "Test that it does what it should for y=10 (False), y=-10 (False), y = 11 (True), y = -11 (True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8LXydxHJfAyu"
   },
   "source": [
    "## Boolean Casting\n",
    "\n",
    "Most python data objects evaluate to true except for the empty string and 0, as well as empty list, empty tuple and empty dictionaries (more about these data types next class)\n",
    "\n",
    "What is each of the datatypes inside the parentheses?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qZDG17mhfAyu",
    "outputId": "ea2a0f76-413b-4c6b-e9e8-ba3ef47e9a6e"
   },
   "outputs": [],
   "source": [
    "bool('') # what is this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yNM3jhoxfAyu",
    "outputId": "f80c4ad2-af02-4318-e0a7-89b80835b8d4"
   },
   "outputs": [],
   "source": [
    "bool(0) # what is this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kxM4GqKHfAyu",
    "outputId": "bbba7940-5aeb-4ed9-8ed6-a96f3c01602d"
   },
   "outputs": [],
   "source": [
    "bool(0.0) # what is this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "660fH2ipfAyu",
    "outputId": "1363472f-4ca3-4a0e-b6b7-4c2b69e245b9"
   },
   "outputs": [],
   "source": [
    "bool([]) # list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EdjZf1UtfAyu",
    "outputId": "03069e47-9e8c-4016-9385-f4985406be7b"
   },
   "outputs": [],
   "source": [
    "bool(()) # tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "swJYKba9fAyu",
    "outputId": "2f576494-f8ac-4fbb-be86-cc14cfa906b7"
   },
   "outputs": [],
   "source": [
    "bool({}) # dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "s1FDQIWmfAyu",
    "outputId": "c007924c-d96f-455e-91df-cb713c09b624"
   },
   "outputs": [],
   "source": [
    "\n",
    "bool(None) #NoneType -- this is a special type often used a placeholder. We will see more about it next time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gKPg7HHxGbHs",
    "outputId": "4f28c27e-4414-4764-ea8f-7253e1635be3"
   },
   "outputs": [],
   "source": [
    "\n",
    "bool(None) #NoneType -- this is a special type often used a placeholder. We will see more about it next time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o3M7gpYlGcoE",
    "outputId": "fa1d7592-f44d-4911-b922-1a773373d6ab"
   },
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PXQt3B2pfj9g"
   },
   "source": [
    "## If / else statements\n",
    "\n",
    "If / else statements let us run code only if code evaluates to True.\n",
    "\n",
    "Python uses indentation after a colon to indicate code blocks.\n",
    "\n",
    "So for example, below if x is equal to 6, the code in the code block, `print(\"hi\")` will run, otherwise it will not run.\n",
    "\n",
    "```\n",
    "if x==6:\n",
    "    print(\"hi\")\n",
    "\n",
    "```\n",
    "\n",
    "An `else` statement after an `if` statement tells Python to run the code inside the `else` codeblock if the `if` codeblock was not run.\n",
    "\n",
    "The below codeblock prints exactly what it says it will.\n",
    "\n",
    "```\n",
    "if x == 6:\n",
    "    print(\"x is 6\")\n",
    "else:\n",
    "    print(\"x is not 6\")\n",
    "```\n",
    "\n",
    "`elif` statements can be placed after after an `if` statement. `elif` statements are checked in order if none of the previous codeblock have run. Python runs code inside an `elif` codeblock if none of the preceding `if` and `elif` statements were true, and if that `elif` statement is True.\n",
    "\n",
    "```\n",
    "if x == 6:\n",
    "    print(\"x is 6\")\n",
    "elif x%2 == 0:\n",
    "    print(\"x is even\")\n",
    "elif x%2 == 1:\n",
    "    print(\"x is odd\")\n",
    "else:\n",
    "    print(\"You should never get here -- every number is either even or odd\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gHgvwRh_kDFr",
    "outputId": "38fe7bde-d470-4240-81e5-19f0fe83b7bf"
   },
   "outputs": [],
   "source": [
    "num=9 # What will this do?\n",
    "if num%2 ==1:\n",
    "    print(\"foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num=8 # What will this do?\n",
    "if num%2 ==1:\n",
    "    print(\"foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pmrUnin6fAyv",
    "outputId": "38881802-8c32-4e17-dd22-4742fabbc38d"
   },
   "outputs": [],
   "source": [
    "num = 8 # What will this do?\n",
    "if num%2 ==1:\n",
    "    print(\"foo\")\n",
    "else:\n",
    "    print(\"bar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 9 # What will this do?\n",
    "if num%2 ==1:\n",
    "    print(\"foo\")\n",
    "else:\n",
    "    print(\"bar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Bg7f_FFxkFZ6",
    "outputId": "88c14cc4-6429-49c9-990a-d327d99c1dd2"
   },
   "outputs": [],
   "source": [
    "num = 3 # What will this do?\n",
    "if num %2 ==1:\n",
    "  print(\"foo\")\n",
    "elif num %3 == 0: # else if\n",
    "  print(\"bar\")\n",
    "else:\n",
    "  print(\"foobar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 6 # What will this do?\n",
    "if num %2 ==1:\n",
    "  print(\"foo\")\n",
    "elif num %3 == 0: # else if\n",
    "  print(\"bar\")\n",
    "else:\n",
    "  print(\"foobar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 4 # What will this do?\n",
    "if num %2 ==1:\n",
    "  print(\"foo\")\n",
    "elif num %3 == 0: # else if\n",
    "  print(\"bar\")\n",
    "else:\n",
    "  print(\"foobar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X_NCY7KJUHpI"
   },
   "source": [
    "## Exercise\n",
    "1. Write something so that, given a variable called `my_number`, if it is less than or equal to 3, it prints \"less than or equal to 3\". Test it on `my_number=3` and `my_number=4`\n",
    "2. Write something so that, given a variable called `my_number`, if it is less than or equal to 3, it prints \"less than or equal to 3\".  Otherwise, print (\"greater than 3\"), Test it on `my_number=3` and `my_number=4`.\n",
    "3. Write something so that, given a variable called `my_int`, if it is not an integer, it prints \"please give me an integer\". Test it on `my_int=3` and `my_int=3.2`\n",
    "4. Write something so that, given a variable called `my_int`, if it is not an integer, it prints \"please give me an integer\". Otherwise, if `my_int` is less than 0, print \"negative\". Test it on `my_int=0`, `my_int=3.2`, and `my_int=-1`.\n",
    "5. Challenge:\n",
    "- Write something so that, given a variable called `my_number`:\n",
    "    - if it is not an integer, it prints \"please give me an integer\"\n",
    "    - otherwise if it is less than 0 it prints \"negative\"\n",
    "    - otherwise if it is between 0 and 10 it prints \"digit\"\n",
    "    - otherwise it prints \"we can't count this on our hands\"\n",
    "- Test it out by setting `my_number` to a few different values and making sure it does what you want / expect."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3.10.7 64-bit",
   "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.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}