week_2_instructor_notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d8769f0a-d22e-4a5e-8e8c-fa93b4bb54a8",
   "metadata": {},
   "source": [
    "# Python Basics Week 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8593729b-d6b8-4eb2-a835-17f3c915c48f",
   "metadata": {},
   "source": [
    "Week 2 topics: \n",
    "- String data\n",
    "- Indexing & Slicing strings\n",
    "- f strings\n",
    "- string operations\n",
    "- the len() function\n",
    "- membership operators & Boolean expression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e7b91a8-7439-4d54-ace6-fab1bab4fb8b",
   "metadata": {
    "tags": []
   },
   "source": [
    "## What is a string?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c3058d-dbfd-4ddc-9137-a80ed2187f8c",
   "metadata": {},
   "source": [
    "Strings are sequences of Unicode characters. Strings are how we represent textual data in Python, among other things."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b74a6c-da47-4c79-809f-9e3c53c205aa",
   "metadata": {},
   "source": [
    "Strings are encased inside of double or single quotation marks. You can use either one, so long as they match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2c06046d-0446-4249-a73e-49853fd61621",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Double quote marks can contain 'single quote marks' without issues\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Double quote marks can contain 'single quote marks' without issues\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d478aa18-af8c-444d-a2ff-b282ce772b07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Likewise, single quotes can contain \"double quotes\" without issues'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Likewise, single quotes can contain \"double quotes\" without issues'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4ba85a16-d046-4b56-a2b3-6b2cc41dbd13",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1653156654.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[24], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    \"but we cannot put \"double quotes\" inside of other double quotes\"\u001b[0m\n\u001b[1;37m                        ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "\"but we cannot put \"double quotes\" inside of other double quotes\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4e7929a3-c8e5-49ab-8b51-e772f30ef9d8",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (434174452.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[25], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    'or 'single quotes' inside of single quotes'\u001b[0m\n\u001b[1;37m         ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "'or 'single quotes' inside of single quotes'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1a139db-75ae-40f4-bb49-45ad6b02bdd8",
   "metadata": {},
   "source": [
    "To make a string that spans multiple lines, use triple quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5eab8dbe-fa68-4819-80f2-87d7ee682fcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a very\n",
      "very\n",
      "very\n",
      "long string\n",
      "\n"
     ]
    }
   ],
   "source": [
    "long_string = \"\"\"I am a very\n",
    "very\n",
    "very\n",
    "long string\n",
    "\"\"\"\n",
    "print(long_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4e630e1-4eea-41bb-892b-f09893c58765",
   "metadata": {},
   "source": [
    "Strings are immutable. You cannot change a string after it has been created, but you can make *new* strings based on existing ones. We'll see how to do this later."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c61c161c-4d06-4c94-9d10-827441a89abf",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57be3800-de1c-4498-8093-d9f8f2d1f8ec",
   "metadata": {},
   "source": [
    "You can think of an index as a way to represent a character's position in a string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e31dec3-b93a-417f-adba-4a4393b52885",
   "metadata": {},
   "source": [
    "Python indexes starting at zero, so the first item or character has an index value of zero. (Not to make things more complicated, but the index is actually calling the position *between* the characters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f214118a-771b-466b-9a90-6ad9eff751d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#string: | P | Y | T | H | O | N |\n",
    "#index:  0   1   2   3   4   5   6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accc4000-80e0-4ce5-96e4-9b03fc071f1e",
   "metadata": {},
   "source": [
    "We can call a specific character in a string using its index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fc566990-0937-402a-92c6-290848c0522b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word = \"python\"\n",
    "word[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "75a78bb0-2c32-486f-9979-dad6a80f5ce3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6d03728c-ff0f-4f58-ba88-c48af7ecdeab",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[36], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# What happens if I call an index that doesn't have a character associated with it?\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m word[\u001b[38;5;241m6\u001b[39m]\n",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "# What happens if I call an index that doesn't have a character associated with it?\n",
    "word[6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae5c754-c517-456b-a3af-eca1fd43f1c6",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47546953-a4b9-4e3d-bf11-a5d9b7520db7",
   "metadata": {},
   "source": [
    "If we want to call out a segment/range/sub-sequence of characters, we call that a \"slice\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "84230b7a-0dbc-4db2-ac69-b7b043cb86a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tho'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[2:5]  # \"give me every character between position 2 and position 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "bb9b60fa-cb67-4f0c-a7f7-cc9ea5907592",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "py\n",
      "py\n"
     ]
    }
   ],
   "source": [
    "#If you want to start at zero, you can specify that, but you don't have to:\n",
    "print(word[0:2])  # return everything between position zero and position 2\n",
    "print(word[:2])  # return everything between the first position (which is index zero) and position 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "264ada07-098f-4980-b4f6-b1d51ec809ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "on\n"
     ]
    }
   ],
   "source": [
    "# You can also slice to the end of a string:\n",
    "print(word[4:])  # return everything between position 4 and the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d2dfb46f-3ca3-4c56-a4c1-3459cd25030a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n"
     ]
    }
   ],
   "source": [
    "# So what will be returned if I call this slice?\n",
    "print(word[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "b1928c58-b274-480a-863b-5b79c2b7ab24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bcc'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I can add a third argument to a slice to specify a step argument or skip-by value:\n",
    "word[0:6:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "735009f2-5c94-4135-9236-d4f3b41921e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pto'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Also the same as:\n",
    "word[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a7d1161-974b-4692-a565-363a917a31a6",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Formatted Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "051ee38e-a6e4-4b65-9b5c-53e3095d1c74",
   "metadata": {},
   "source": [
    "We can embed variable values within a string by using an `f'` string. Curly brackets are used around the name of any variable that you wish to include in the string. This is my (Shelby's) preferred way to write print statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "685ddf7c-bd09-4e17-9d98-9bb66634818b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Shelby Watson! How are you today?\n",
      "Hello, Shelby Watson! How are you today?\n"
     ]
    }
   ],
   "source": [
    "name = \"Shelby Watson\"\n",
    "\n",
    "# without f string:\n",
    "print(\"Hello, \", name, \"! How are you today?\", sep='')  # have to change the separator (by default, whitespace) to account for the exclamation point\n",
    "\n",
    "#with f string:\n",
    "print(f\"Hello, {name}! How are you today?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f5f78e36-53bb-4c1e-aca7-af300b0e22d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, S, how are you today?\n"
     ]
    }
   ],
   "source": [
    "# Using an f string with an index:\n",
    "print(f'Hello, {name[0]}, how are you today?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "24ab28fc-2ff7-4c07-930e-3127905af028",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Shelby, how are you today?\n"
     ]
    }
   ],
   "source": [
    "# Using an f string with a slice:\n",
    "print(f\"Hello {name[:6]}, how are you today?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ce9fde-c855-45e2-8663-15a9414090a7",
   "metadata": {},
   "source": [
    "## String Operations & Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02cc8808-d485-4ca7-94f5-5cc52b16bb5d",
   "metadata": {},
   "source": [
    "### String Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d557481-31d5-4d4a-9a2c-99d272580412",
   "metadata": {},
   "source": [
    "You can join strings together with the concatination operator `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ec14c480-77a0-4e54-8479-35cb259ecadf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shelby Watson\n"
     ]
    }
   ],
   "source": [
    "name = \"Shelby\" + \" \" + \"Watson\"\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3efc33ab-62f7-4283-8d4e-73d7e18d7e5b",
   "metadata": {},
   "source": [
    "Similarly, the `*` operator, when used on a string, does repetition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ff8a48b-7432-4792-b672-95f2daea27c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = \"Hello! \"\n",
    "greeting*5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fff8a28-4624-4d42-a820-3678c4b957c3",
   "metadata": {},
   "source": [
    "### String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b0cc6f-b23a-4ce6-9dd4-23efce188028",
   "metadata": {},
   "source": [
    "A method is similar to a function but has slightly different syntax. The dot notation specifies the method and the string to apply the method to. If the method takes arguments, those go in the parentheses. If the method takes no argument, leave the parentheses empty. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "671495f0-6746-468f-8f4a-9a6ddbb1d547",
   "metadata": {},
   "outputs": [],
   "source": [
    "word = \"Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a716cc5e-13fb-4fd2-8d2b-6ce39400d4b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "word.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bbc45fb-bd54-47f7-8176-56ea214c77e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "word.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fa69f2e-2b8c-47d0-8bee-10a4e625e4ea",
   "metadata": {},
   "source": [
    "*n.b.* String methods return new values - they do not change the original string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4847bee9-2a11-4195-91db-4ce9756e5e90",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e4bd82bb-5d8f-4a77-81f0-f3baf59341ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'What a lovely day to learn to code.'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentance = \"what a lovely day to learn to code.\"\n",
    "sentance.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d35a835e-4b85-40de-830f-ddee88739630",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'What A Lovely Day To Learn To Code.'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#vs\n",
    "sentance.title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8616f08d-0ea7-4aec-b06c-f37b1eed7a56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['what', 'a', 'lovely', 'day', 'to', 'learn', 'to', 'code.']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentance.split()  # Splits on whitespace by default. Returns a list, which we will learn more about next week!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "aa9f8849-8e55-4c04-a36c-a5e66b1206db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['what a ', 'ove', 'y day to ', 'earn to code.']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentance.split(\"l\")  # if you want to split on something other than whitespace, enter it as an argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2b3765fc-b579-4694-ac0d-0e943f6f8901",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '8', '9', '4', '6', '2', '4', '5', '6', '2', '1', '9']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = \"1-8-9-4-6-2-4-5-6-2-1-9\"\n",
    "nums.split(\"-\")  # you can change what you want to split on by specifying it as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "21fedecc-2306-481a-95ed-0d6faefc11c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '8', '9', '4', '6', '2', '4', '5', '6', '2', '1', '9']\n",
      "1-8-9-4-6-2-4-5-6-2-1-9\n"
     ]
    }
   ],
   "source": [
    "# now put it back together\n",
    "nums_list = nums.split(\"-\")\n",
    "print(nums_list)\n",
    "\n",
    "nums_string = \"-\".join(nums_list)  #specify the separator first, then specify the list to join into a string\n",
    "print(nums_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6063cb23-569e-4e04-8376-f8630ac81956",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jello world!'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phrase = \"hello world!\"\n",
    "phrase.replace(\"h\",\"j\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "2ecd2f09-580e-424c-91a0-f47f7a259194",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n"
     ]
    }
   ],
   "source": [
    "# But remember, this doesn't change the actual string:\n",
    "print(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "7fcfb90f-3ea5-49ab-8707-06a9daf95c94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jello world!\n"
     ]
    }
   ],
   "source": [
    "# If we wanted to keep it permanently, we have to assign it to its own variable:\n",
    "jello_phrase = phrase.replace(\"h\",\"j\")\n",
    "print(jello_phrase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "add5d6d3-c8ac-44d6-9ed1-86174a2a83f7",
   "metadata": {},
   "source": [
    "## The Len Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17fe4181-41ba-4312-85e8-62be4d071deb",
   "metadata": {},
   "source": [
    "Len (or \"length\") is a built-in function that returns the number of characters in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b507d6e8-e27e-41a6-9963-522c5d000901",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "5db56473-d8bb-4ae7-9448-c5587c4ae600",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Pay attention:\n",
    "fruit = \"strawberry\"\n",
    "\n",
    "print(len(fruit))\n",
    "\n",
    "print(len(\"fruit\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9052c6e-c3c7-4076-8346-897b732e2d32",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Membership Operators & Boolean Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e64c9c5-6298-4fbc-a9ad-fd6d02e0a8a0",
   "metadata": {},
   "source": [
    "The membership operator checks whether a value is present. The operators are `\"in\"` (and `not in`). They return a Boolean (True or False) value. You can also use Boolean expressions (`and`, `or`, and `not`) to add certain conditions to your statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "d71a9f46-12a9-4b33-8611-67316fdb8bac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"i\" in \"team\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "a95bfdb2-f5c9-40fe-b5f0-5f5a9db29d18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"m\" in \"team\" and \"e\" in \"team\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "afc3a4d1-a4ce-4cd0-8cea-599d0d890967",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "What is your word? bicycle\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Scrabble Scores\n",
    "# Return \"True\" if the word contains at least one high-scoring (10 point) Scrabble letter\n",
    "word = input(\"What is your word?\")\n",
    "\"q\" in word.lower() or \"z\" in word.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d94a3b4b-5096-4da6-8561-e39afb89c3bc",
   "metadata": {},
   "source": [
    "You can imagine that if we had many different conditions we wanted to check, like all the scrabble letters worth more than four points, that this could get very tedious. Next week, we'll look at creating lists in Python and traversing them using loops."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a9a17a-ad5d-4b01-9618-a44e6e194b70",
   "metadata": {
    "tags": []
   },
   "source": [
    "## (If time) Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c36d5e7-bc66-47dd-b672-6ec2f03abb17",
   "metadata": {},
   "source": [
    "Libraries/packages are collections of functions and/or data that help expand on Python's core functions. There are tons of Python packages available. As you continue learning (and read more code!) you will start to become familiar with some of the more common libraries. Libraries can also help you accomplish very specific tasks - for example, conducting advanced statistical analysis, reading genomic data, making plots and charts, etc. without having to write a lot of custom functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2223a857-9b08-4ca3-9d9f-b94abcc70398",
   "metadata": {},
   "source": [
    "### Installing Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13b5e045-a7f2-4aca-80ce-f7176eb13e54",
   "metadata": {},
   "source": [
    "If you installed Python through Anaconda, you already have most commonly used Python libraries installed on your computer. However, if you need to install a new library that you don't already have, you will use pip. You should only have to install a library on your computer once (unless it needs to be updated).\n",
    "\n",
    "Starting a command with an exclamation point ( ! ) passes the command to the shell. You can also use the same syntax (minus the \"!\" ) in the command line/terminal/Bash shell to install rather than doing it through your IDE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08034fc4-2634-4c55-9aba-135986896620",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3594fc60-f255-44a3-ab48-55c9f3f503e2",
   "metadata": {},
   "source": [
    "(you will already have the numpy library installed on your computer through Anaconda)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef15728-59d2-4fab-8c1c-054de7110187",
   "metadata": {},
   "source": [
    "Doing this installs the library on your computer, but it's not actually available in your notebook yet. In order to make it available in our notebook, we need to import the library. You only need to import a package once per notebook. By convention, importing the packages required for your code should be the very first thing you see when you open a script. This lets other people using your code know what they need to install and makes all the functions you need available up front."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "634b6f63-e89b-4553-924c-5253fc6d0476",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a63dab64-b4c4-4479-bfd1-f3981c95fb3c",
   "metadata": {},
   "source": [
    "In order to save on the amount of typing that you have to do, it is convention to import some Python packages with \"aliases\" or shortened names. This is done with the `as` keyword. The preferred alias is usually included in the package's documentation. A few common ones are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f002c182-7c5d-4e50-a12c-c181122ef762",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}