2-strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 5 Lecture - Strings\n",
    "\n",
    "* What is a String\n",
    "* String Slicing\n",
    "* String Comparison\n",
    "* String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is a string?\n",
    "\n",
    "You already know about strings, they are a basic Python data type! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"I am a string\"\n",
    "type(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, strings are actually a more complicated data structure with a bunch of useful features and functions. \n",
    "\n",
    "Strings are a *sequence* of characters. Very similar to a *list*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over a string as a sequence of characters\n",
    "for character in my_string:\n",
    "    print(character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because strings are sequences, that means you can use the indexing syntax to access parts of a string.\n",
    "* Remember use the `variable_name[x]` notation to get the item at index position `x` from the list or string stored in `variable_name`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# give me the character at index position 5\n",
    "my_string[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, indexing starts at 0 intead of 1, so it is easy to end out \"out of range\" when you aren't careful with your counting. Ugh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the length of the string using the len() function\n",
    "string_length = len(my_string)\n",
    "print(string_length) # Should return 13 becuase the string has 13 characters\n",
    "# grab the last item by using string_length as the index\n",
    "my_string[string_length]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ugh. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try it again with some math\n",
    "# get the length of the string using the len() function\n",
    "string_length = len(my_string)\n",
    "print(string_length) # Should return 13 becuase the string has 13 characters\n",
    "# grab the last item by using string_length-1 as the index\n",
    "my_string[string_length - 1] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This works because the last item is in the 12th index position. Fortunately, Python has an easier way of grabbing the last item. Remember, we used it with lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing Strings\n",
    "![No Strings Attached](https://media.giphy.com/media/jnJLHYI447XkhFSMLi/giphy.gif)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use the same slicing notation we used on lists with strings. Very handy for quickly cleaning or subsetting strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new string\n",
    "city_name = \"Pittsburgh\"\n",
    "print(city_name[2:5])\n",
    "print(city_name[-5:]) # slice startings and the end minus 5 and continue to the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print the fight song, but what is the index position?\n",
    "print(\"Hail to \" + city_name[0:???])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Comparison\n",
    "\n",
    "We have compared strings with the equals operator (`==`) to see if two strings are the same. You can also perform strings comparisons with the other comparison operators (`<`, `>`). With less than or greather than, Python will compare each letter in a pairwise comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# is the string \"one\" less than the string \"two\"\n",
    "\"One\" < \"Two\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# is one less than this other, rather large, number?\n",
    "\"One\" < \"Fourteen million trillion gazillion\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wut? Why is \"One\" less than that other big number? Because \"O\" is greater than \"F\"\n",
    "* The `ord()` function returns the Unicode number for a one-character string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"An O corresponds to the number:\", ord(\"O\"))\n",
    "print(\"A F corresponds to the number:\", ord(\"F\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why do those characters correspond to those numbers? Becuase of [UNICODE]()\n",
    "![Unicode Unicorn](https://cdn.dribbble.com/users/1318269/screenshots/11898064/media/7377c67c5dd852bf22d16630099d5794.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides an `in` operator to check to see if a value is present in a squence. This means it works for both lists and strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a list of cheeses\n",
    "cheeses = ['Cheddar', 'Edam', 'Gouda', 'Brie', \"Pepper Jack\"]\n",
    "# is the strings \"Brie\" in my list of cheeses\n",
    "\"Brie\" in cheeses # yum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, computers are very precise and particular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# is \"chedder in cheeses\"\n",
    "\"cheddar\" in cheeses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why did we get that answer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Is the string inside another string\n",
    "\"Ched\" in \"Cheddar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# is the item inside the list\n",
    "\"Ched\" in cheeses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comparisons and string comparisons operate very similarly. But it is important to understand the conceptual difference.\n",
    "* list comparison - is this value present as an item in the list\n",
    "* string comparison - is this sequence of characters present in this other string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using the in keyword in a conditional \n",
    "if \"Cheddar\" in cheeses:\n",
    "    print(\"All is good\")\n",
    "else:\n",
    "    print(\"Go grocery shopping\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a big string of rambling thoughts on cheese\n",
    "cheesey_monolog = \"\"\"\n",
    "I'd say my favorite cheese is chedder and thats probably because I am from Vermont, but I also like brie. Brie is \n",
    "really good baked with some pears and pastry...yeah, that's really good. But don't eat too much, otherwise you will\n",
    "spoil your dinner.\"\"\"\n",
    "# check to see if the string \"chedder\" is somewhere in the monolog\n",
    "if \"chedder\" in cheesey_monolog:\n",
    "    print(\"Yes\")\n",
    "else:\n",
    "    print(\"No\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Methods\n",
    "![Method Man](https://media.giphy.com/media/JnLSi2bWr80p2/giphy.gif)\n",
    "\n",
    "Because Python strings are a more complex data structure (similar to Lists), which means there a a bunch of functions (technically called \"methods\") designed to work specifically with strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_of_words = \"A string of words becomes a list\"\n",
    "# the split method is an oft used string method\n",
    "list_of_words = string_of_words.split()\n",
    "print(list_of_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is another string method that allows you to go in reverse, but it is a bit wonky"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# join a list together into a single string\n",
    "\" \".join(list_of_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is happening here, why can't we say `list_of_words.join()`\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_words.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is because `join()` is a *string method* that only works on strings. The variable `list_of_words` is a list, which doesn't have a method called join.\n",
    "\n",
    "What we do instead is take a string, in this case a space, and use its join method to create a string from the list passed to the function. The string we put first gets used as a separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# join a list together into a single string\n",
    "\"*\".join(list_of_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# join a list together into a single string\n",
    "\"||||\".join(list_of_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The official Python documentation has an [explaination of all string methods](https://docs.python.org/3/library/stdtypes.html#string-methods).\n",
    "\n",
    "You can also use the autocomplete feature of Jupyter. Put the cursor after the \".\" below and hit TAB. That will show you all the possible string methods available.\n",
    "\n",
    "Look at the documentation and autocomplete to try a couple of string methods below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try a strig method\n",
    "\"a string of things\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try another string method\n",
    "\"a string of things\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# one more\n",
    "\"a string of things\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"something\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting it All Together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use string looping, slicing, and string methods to do some data science on strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a string of some classic song lyrics\n",
    "lyric = \"cash rules everything around me\"\n",
    "# create an empty list for storing letters\n",
    "letters = []\n",
    "# Use the split function to create a list of words and loop over the list\n",
    "for word in lyric.split():\n",
    "    # append the first letter of the word converted to uppercase to the list \n",
    "    letters.append(word[0].upper()) \n",
    "\n",
    "# Join all the items in the string together with periods\n",
    "greatest_wu_tang_song = \".\".join(letters)\n",
    "print(greatest_wu_tang_song)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}