Writing Efficient Python Code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fbd63198",
   "metadata": {},
   "source": [
    "A taste of things to come\n",
    "In this exercise, you'll explore both the Non-Pythonic and Pythonic ways of looping over a list.\n",
    "\n",
    "names = ['Jerry', 'Kramer', 'Elaine', 'George', 'Newman']\n",
    "Suppose you wanted to collect the names in the above list that have six letters or more. In other programming languages, the typical approach is to create an index variable (i), use i to iterate over the list, and use an if statement to collect the names with six letters or more:\n",
    "\n",
    "i = 0\n",
    "new_list= []\n",
    "while i < len(names):\n",
    "    if len(names[i]) >= 6:\n",
    "        new_list.append(names[i])\n",
    "    i += 1\n",
    "Let's explore some more Pythonic ways of doing this.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Print the list, new_list, that was created using a Non-Pythonic approach.\n",
    "A more Pythonic approach would loop over the contents of names, rather than using an index variable. Print better_list.\n",
    "The best Pythonic way of doing this is by using list comprehension. Print best_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45e87bff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the list created using the Non-Pythonic approach\n",
    "i = 0\n",
    "new_list= []\n",
    "while i < len(names):\n",
    "    if len(names[i]) >= 6:\n",
    "        new_list.append(names[i])\n",
    "    i += 1\n",
    "print(new_list)\n",
    "\n",
    "# Print the list created by looping over the contents of names\n",
    "better_list = []\n",
    "for name in names:\n",
    "    if len(name) >= 6:\n",
    "        better_list.append(name)\n",
    "print(better_list)\n",
    "\n",
    "# Print the list created by using list comprehension\n",
    "best_list = [name for name in names if len(name) >= 6]\n",
    "print(best_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2d2c3be",
   "metadata": {},
   "source": [
    "Built-in practice: range()\n",
    "In this exercise, you will practice using Python's built-in function range(). Remember that you can use range() in a few different ways:\n",
    "\n",
    "1) Create a sequence of numbers from 0 to a stop value (which is exclusive). This is useful when you want to create a simple sequence of numbers starting at zero:\n",
    "\n",
    "range(stop)\n",
    "\n",
    "#Example\n",
    "list(range(11))\n",
    "\n",
    "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "2) Create a sequence of numbers from a start value to a stop value (which is exclusive) with a step size. This is useful when you want to create a sequence of numbers that increments by some value other than one. For example, a list of even numbers:\n",
    "\n",
    "range(start, stop, step)\n",
    "\n",
    "#Example\n",
    "list(range(2,11,2))\n",
    "\n",
    "[2, 4, 6, 8, 10]\n",
    "\n",
    "\n",
    "Instructions\n",
    "\n",
    "Create a range object that starts at zero and ends at five. Only use a stop argument.\n",
    "Convert the nums variable into a list called nums_list.\n",
    "Create a new list called nums_list2 that starts at one, ends at eleven, and increments by two by unpacking a range object using the star character (*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52ce84e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a range object that goes from 0 to 5\n",
    "nums = range(6)\n",
    "print(type(nums))\n",
    "\n",
    "# Convert nums to a list\n",
    "nums_list = list(nums)\n",
    "print(nums_list)\n",
    "\n",
    "# Create a new list of odd numbers from 1 to 11 by unpacking a range object\n",
    "nums_list2 = [*range(1,12,2)]\n",
    "print(nums_list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02fa2bdf",
   "metadata": {},
   "source": [
    "Built-in practice: enumerate()\n",
    "In this exercise, you'll practice using Python's built-in function enumerate(). This function is useful for obtaining an indexed list. For example, suppose you had a list of people that arrived at a party you are hosting. The list is ordered by arrival (Jerry was the first to arrive, followed by Kramer, etc.):\n",
    "\n",
    "names = ['Jerry', 'Kramer', 'Elaine', 'George', 'Newman']\n",
    "If you wanted to attach an index representing a person's arrival order, you could use the following for loop:\n",
    "\n",
    "indexed_names = []\n",
    "for i in range(len(names)):\n",
    "    index_name = (i, names[i])\n",
    "    indexed_names.append(index_name)\n",
    "\n",
    "[(0,'Jerry'),(1,'Kramer'),(2,'Elaine'),(3,'George'),(4,'Newman')]\n",
    "But, that's not the most efficient solution. Let's explore how to use enumerate() to make this more efficient.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Instead of using for i in range(len(names)), update the for loop to use i as the index variable and name as the iterator variable and use enumerate().\n",
    "Rewrite the previous for loop using enumerate() and list comprehension to create a new list, indexed_names_comp.\n",
    "Create another list (indexed_names_unpack) by using the star character (*) to unpack the enumerate object created from using enumerate() on names. This time, start the index for enumerate() at one instead of zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86b0eb1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rewrite the for loop to use enumerate\n",
    "indexed_names = []\n",
    "for i,name in enumerate(names):\n",
    "    index_name = (i,name)\n",
    "    indexed_names.append(index_name) \n",
    "print(indexed_names)\n",
    "\n",
    "# Rewrite the above for loop using list comprehension\n",
    "indexed_names_comp = [(i,name) for i,name in enumerate(names)]\n",
    "print(indexed_names_comp)\n",
    "\n",
    "# Unpack an enumerate object with a starting index of one\n",
    "indexed_names_unpack = [*enumerate(names, 1)]\n",
    "print(indexed_names_unpack)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fe62f5a",
   "metadata": {},
   "source": [
    "Built-in practice: map()\n",
    "In this exercise, you'll practice using Python's built-in map() function to apply a function to every element of an object. Let's look at a list of party guests:\n",
    "\n",
    "names = ['Jerry', 'Kramer', 'Elaine', 'George', 'Newman']\n",
    "Suppose you wanted to create a new list (called names_uppercase) that converted all the letters in each name to uppercase. you could accomplish this with the below for loop:\n",
    "\n",
    "names_uppercase = []\n",
    "\n",
    "for name in names:\n",
    "  names_uppercase.append(name.upper())\n",
    "\n",
    "['JERRY', 'KRAMER', 'ELAINE', 'GEORGE', 'NEWMAN']\n",
    "Let's explore using the map() function to do this more efficiently in one line of code.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use map() and the method str.upper() to convert each name in the list names to uppercase. Save this to the variable names_map.\n",
    "Print the data type of names_map.\n",
    "Unpack the contents of names_map into a list called names_uppercase using the star character (*).\n",
    "Print names_uppercase and observe its contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf95fbd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use map to apply str.upper to each element in names\n",
    "names_map  = map(str.upper, names)\n",
    "\n",
    "# Print the type of the names_map\n",
    "print(type(names_map))\n",
    "\n",
    "# Unpack names_map into a list\n",
    "names_uppercase = [*list(names_map)]\n",
    "\n",
    "# Print the list created above\n",
    "print(names_uppercase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ce155a7",
   "metadata": {},
   "source": [
    "Practice with NumPy arrays\n",
    "Let's practice slicing numpy arrays and using NumPy's broadcasting concept. Remember, broadcasting refers to a numpy array's ability to vectorize operations, so they are performed on all elements of an object at once.\n",
    "\n",
    "A two-dimensional numpy array has been loaded into your session (called nums) and printed into the console for your convenience. numpy has been imported into your session as np.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Print the second row of nums.\n",
    "Print the items of nums that are greater than six.\n",
    "Create nums_dbl that doubles each number in nums.\n",
    "Replace the third column in nums with a new column that adds 1 to each item in the original column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31894820",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print second row of nums\n",
    "print(nums[1,:])\n",
    "\n",
    "# Print all elements of nums that are greater than six\n",
    "print(nums[nums > 6])\n",
    "\n",
    "# Double every element of nums\n",
    "nums_dbl = nums * 2\n",
    "print(nums_dbl)\n",
    "\n",
    "# Replace the third column of nums\n",
    "nums[:,2] = nums[:,2] + 1\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decde739",
   "metadata": {},
   "source": [
    "Bringing it all together: Festivus!\n",
    "In this exercise, you will be throwing a party—a Festivus if you will!\n",
    "\n",
    "You have a list of guests (the names list). Each guest, for whatever reason, has decided to show up to the party in 10-minute increments. For example, Jerry shows up to Festivus 10 minutes into the party's start time, Kramer shows up 20 minutes into the party, and so on and so forth.\n",
    "\n",
    "We want to write a few simple lines of code, using the built-ins we have covered, to welcome each of your guests and let them know how many minutes late they are to your party. Note that numpy has been imported into your session as np and the names list has been loaded as well.\n",
    "\n",
    "Let's welcome your guests!\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use range() to create a list of arrival times (10 through 50 incremented by 10). Create the list arrival_times by unpacking the range object.\n",
    "You realize your clock is three minutes fast. Convert the arrival_times list into a numpy array (called arrival_times_np) and use NumPy broadcasting to subtract three minutes from each arrival time.\n",
    "Use list comprehension with enumerate() to pair each guest in the names list to their updated arrival time in the new_times array. You'll need to use the index variable created from using enumerate() on new_times to index the names list.\n",
    "A function named welcome_guest() has been pre-loaded into your session. Use map() to apply this function to each element of the guest_arrivals list and save it as the variable welcome_map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af00493d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of arrival times\n",
    "arrival_times = [*range(10, 60, 10)]\n",
    "\n",
    "print(arrival_times)\n",
    "\n",
    "# Convert arrival_times to an array and update the times\n",
    "arrival_times_np = np.array(arrival_times)\n",
    "new_times = arrival_times_np - 3\n",
    "\n",
    "# Use list comprehension and enumerate to pair guests to new times\n",
    "guest_arrivals = [(names[i],time) for i,time in enumerate(new_times)]\n",
    "\n",
    "# Map the welcome_guest function to each (guest,time) pair\n",
    "welcome_map = map(welcome_guest ,guest_arrivals)\n",
    "\n",
    "guest_welcomes = [*welcome_map]\n",
    "print(*guest_welcomes, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc8f62e",
   "metadata": {},
   "source": [
    "Using %timeit: your turn!\n",
    "You'd like to create a list of integers from 0 to 50 using the range() function. However, you are unsure whether using list comprehension or unpacking the range object into a list is faster. Let's use %timeit to find the best implementation.\n",
    "\n",
    "For your convenience, a reference table of time orders of magnitude is provided below (faster at the top).\n",
    "\n",
    "symbol\tname\tunit (s)\n",
    "ns\tnanosecond\t10-9\n",
    "µs (us)\tmicrosecond\t10-6\n",
    "ms\tmillisecond\t10-3\n",
    "s\tsecond\t100\n",
    "Instructions\n",
    "\n",
    "Use list comprehension and range() to create a list of integers from 0 to 50 called nums_list_comp.\n",
    "Use range() to create a list of integers from 0 to 50 and unpack its contents into a list called nums_unpack."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7364f4e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of integers (0-50) using list comprehension\n",
    "nums_list_comp = [num for num in range(51)]\n",
    "print(nums_list_comp)\n",
    "\n",
    "# Create a list of integers (0-50) by unpacking range\n",
    "nums_unpack = [*list(nums_list_comp)]\n",
    "print(nums_unpack)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9724ba97",
   "metadata": {},
   "source": [
    "Using %timeit: formal name or literal syntax\n",
    "Python allows you to create data structures using either a formal name or a literal syntax. In this exercise, you'll explore how using a literal syntax for creating a data structure can speed up runtimes.\n",
    "\n",
    "data structure\tformal name\tliteral syntax\n",
    "list\tlist()\t[]\n",
    "dictionary\tdict()\t{}\n",
    "tuple\ttuple()\t()\n",
    "\n",
    "Instructions\n",
    "\n",
    "Create an empty list called formal_list using the formal name (list()).\n",
    "Create an empty list called literal_list using the literal syntax ([]).\n",
    "Print out the type of formal_list and literal_list to show that both naming conventions create a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a3dcaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list using the formal name\n",
    "formal_list = list()\n",
    "print(formal_list)\n",
    "\n",
    "# Create a list using the literal syntax\n",
    "literal_list = []\n",
    "print(literal_list)\n",
    "\n",
    "# Print out the type of formal_list\n",
    "print(type(formal_list))\n",
    "\n",
    "# Print out the type of literal_list\n",
    "print(type(literal_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c48e036",
   "metadata": {},
   "source": [
    "Bringing it all together: Star Wars profiling\n",
    "A list of 480 superheroes has been loaded into your session (called heroes) as well as a list of each hero's corresponding publisher (called publishers).\n",
    "\n",
    "You'd like to filter the heroes list based on a hero's specific publisher, but are unsure which of the below functions is more efficient.\n",
    "\n",
    "def get_publisher_heroes(heroes, publishers, desired_publisher):\n",
    "\n",
    "    desired_heroes = []\n",
    "\n",
    "    for i,pub in enumerate(publishers):\n",
    "        if pub == desired_publisher:\n",
    "            desired_heroes.append(heroes[i])\n",
    "\n",
    "    return desired_heroes\n",
    "def get_publisher_heroes_np(heroes, publishers, desired_publisher):\n",
    "\n",
    "    heroes_np = np.array(heroes)\n",
    "    pubs_np = np.array(publishers)\n",
    "\n",
    "    desired_heroes = heroes_np[pubs_np == desired_publisher]\n",
    "\n",
    "    return desired_heroes\n",
    "Instructions\n",
    "\n",
    "Use the get_publisher_heroes() function and the get_publisher_heroes_np() function to collect heroes from the Star Wars universe. The desired_publisher for Star Wars is 'George Lucas'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56e459b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use get_publisher_heroes() to gather Star Wars heroes\n",
    "star_wars_heroes = get_publisher_heroes(heroes, publishers, 'George Lucas')\n",
    "\n",
    "print(star_wars_heroes)\n",
    "print(type(star_wars_heroes))\n",
    "\n",
    "# Use get_publisher_heroes_np() to gather Star Wars heroes\n",
    "star_wars_heroes_np = get_publisher_heroes_np(heroes, publishers, 'George Lucas')\n",
    "\n",
    "print(star_wars_heroes_np)\n",
    "print(type(star_wars_heroes_np))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1774868c",
   "metadata": {},
   "source": [
    "Combining Pokémon names and types\n",
    "Three lists have been loaded into your session from a dataset that contains 720 Pokémon:\n",
    "\n",
    "The names list contains the names of each Pokémon.\n",
    "The primary_types list contains the corresponding primary type of each Pokémon.\n",
    "The secondary_types list contains the corresponding secondary type of each Pokémon (nan if the Pokémon has only one type).\n",
    "We want to combine each Pokémon's name and types together so that you easily see a description of each Pokémon. Practice using zip() to accomplish this task.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Combine the names list and the primary_types list into a new list object (called names_type1).\n",
    "Combine names, primary_types, and secondary_types (in that order) using zip() and unpack the zip object into a new list.\n",
    "Use zip() to combine the first five items from the names list and the first three items from the primary_types list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8efb6907",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine names and primary_types\n",
    "names_type1 = [*zip(names, primary_types)]\n",
    "\n",
    "print(*names_type1[:5], sep='\\n')\n",
    "\n",
    "# Combine all three lists together\n",
    "names_types = [*zip(names, primary_types, secondary_types)]\n",
    "\n",
    "print(*names_types[:5], sep='\\n')\n",
    "\n",
    "# Combine five items from names and three items from primary_types\n",
    "differing_lengths = [*zip(names[:5], primary_types[:3])]\n",
    "\n",
    "print(*differing_lengths, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb979055",
   "metadata": {},
   "source": [
    "Counting Pokémon from a sample\n",
    "A sample of 500 Pokémon has been generated, and three lists from this sample have been loaded into your session:\n",
    "\n",
    "The names list contains the names of each Pokémon in the sample.\n",
    "The primary_types list containing the corresponding primary type of each Pokémon in the sample.\n",
    "The generations list contains the corresponding generation of each Pokémon in the sample.\n",
    "You want to quickly gather a few counts from these lists to better understand the sample that was generated. Use Counter from the collections module to explore what types of Pokémon are in your sample, what generations they come from, and how many Pokémon have a name that starts with a specific letter.\n",
    "\n",
    "Counter has already been imported into your session for convenience.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Collect the count of each primary type from the sample.\n",
    "Collect the count of each generation from the sample.\n",
    "Use list comprehension to collect the first letter of each Pokémon in the names list. Save this as starting_letters.\n",
    "Collect the count of starting letters from the starting_letters list. Save this as starting_letters_count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a94f0e9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collect the count of primary types\n",
    "type_count = Counter(primary_types)\n",
    "print(type_count, '\\n')\n",
    "\n",
    "# Collect the count of generations\n",
    "gen_count = Counter(generations)\n",
    "print(gen_count, '\\n')\n",
    "\n",
    "# Use list comprehension to get each Pokémon's starting letter\n",
    "starting_letters = [name[0] for name in names]\n",
    "\n",
    "# Collect the count of Pokémon for each starting_letter\n",
    "starting_letters_count = Counter(starting_letters)\n",
    "print(starting_letters_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98e1acad",
   "metadata": {},
   "source": [
    "Combinations of Pokémon\n",
    "Ash, a Pokémon trainer, encounters a group of five Pokémon. These Pokémon have been loaded into a list within your session (called pokemon) and printed into the console for your convenience.\n",
    "\n",
    "Ash would like to try to catch some of these Pokémon, but his Pokédex can only store two Pokémon at a time. Let's use combinations from the itertools module to see what the possible pairs of Pokémon are that Ash could catch.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Import combinations from itertools.\n",
    "Create a combinations object called combos_obj that contains all possible pairs of Pokémon from the pokemon list. A pair has 2 Pokémon.\n",
    "Unpack combos_obj into a list called combos_2.\n",
    "Ash upgraded his Pokédex so that it can now store four Pokémon. Use combinations to collect all possible combinations of 4 different Pokémon. Save these combinations directly into a list called combos_4 using the star character (*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9321220e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import combinations from itertools\n",
    "from itertools import combinations\n",
    "\n",
    "# Create a combination object with pairs of Pokémon\n",
    "combos_obj = combinations(pokemon, 2)\n",
    "print(type(combos_obj), '\\n')\n",
    "\n",
    "# Convert combos_obj to a list by unpacking\n",
    "combos_2 = [*combos_obj]\n",
    "print(combos_2, '\\n')\n",
    "\n",
    "# Collect all possible combinations of 4 Pokémon directly into a list\n",
    "combos_4 = [*combinations(pokemon, 4)]\n",
    "print(combos_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32566c9",
   "metadata": {},
   "source": [
    "Comparing Pokédexes\n",
    "Two Pokémon trainers, Ash and Misty, would like to compare their individual collections of Pokémon. Let's see what Pokémon they have in common and what Pokémon Ash has that Misty does not.\n",
    "\n",
    "Both Ash and Misty's Pokédex (their collection of Pokémon) have been loaded into your session as lists called ash_pokedex and misty_pokedex. They have been printed into the console for your convenience.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Convert both lists (ash_pokedex and misty_pokedex) to sets called ash_set and misty_set respectively.\n",
    "Find the Pokémon that both Ash and Misty have in common using a set method.\n",
    "Find the Pokémon that are within Ash's Pokédex but are not within Misty's Pokédex with a set method.\n",
    "Use a set method to find the Pokémon that are unique to either Ash or Misty (i.e., the Pokémon that exist in exactly one of the Pokédexes but not both)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c1040df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert both lists to sets\n",
    "ash_set = set(ash_pokedex)\n",
    "misty_set = set(misty_pokedex)\n",
    "\n",
    "# Find the Pokémon that exist in both sets\n",
    "both = ash_set.intersection(misty_set)\n",
    "print(both)\n",
    "\n",
    "# Find the Pokémon that Ash has and Misty does not have\n",
    "ash_only = ash_set.difference(misty_set)\n",
    "print(ash_only)\n",
    "\n",
    "# Find the Pokémon that are in only one set (not both)\n",
    "unique_to_set = ash_set.symmetric_difference(misty_set)\n",
    "print(unique_to_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35a46ea3",
   "metadata": {},
   "source": [
    "Searching for Pokémon\n",
    "Two Pokémon trainers, Ash and Brock, have a collection of ten Pokémon each. Each trainer's Pokédex (their collection of Pokémon) has been loaded into your session as lists called ash_pokedex and brock_pokedex respectively.\n",
    "\n",
    "You'd like to see if certain Pokémon are members of either Ash or Brock's Pokédex.\n",
    "\n",
    "Let's compare using a set versus using a list when performing this membership testing.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Convert Brock's Pokédex list (brock_pokedex) to a set called brock_pokedex_set.\n",
    "Check if 'Psyduck' is in Ash's Pokédex list (ash_pokedex) and if 'Psyduck' is in Brock's Pokédex set (brock_pokedex_set).\n",
    "Check if 'Machop' is in Ash's Pokédex list (ash_pokedex) and if 'Machop' is in Brock's Pokédex set (brock_pokedex_set)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "246bff2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert Brock's Pokédex to a set\n",
    "brock_pokedex_set = set(brock_pokedex)\n",
    "print(brock_pokedex_set)\n",
    "\n",
    "# Check if Psyduck is in Ash's list and Brock's set\n",
    "print('Psyduck' in ash_pokedex)\n",
    "print('Psyduck' in brock_pokedex_set)\n",
    "\n",
    "# Check if Machop is in Ash's list and Brock's set\n",
    "print('Machop' in ash_pokedex)\n",
    "print('Machop' in brock_pokedex_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6fc690e",
   "metadata": {},
   "source": [
    "Gathering unique Pokémon\n",
    "A sample of 500 Pokémon has been created with replacement (meaning a Pokémon could be selected more than once and duplicates exist within the sample).\n",
    "\n",
    "Three lists have been loaded into your session:\n",
    "\n",
    "The names list contains the names of each Pokémon in the sample.\n",
    "The primary_types list containing the corresponding primary type of each Pokémon in the sample.\n",
    "The generations list contains the corresponding generation of each Pokémon in the sample.\n",
    "The below function was written to gather unique values from each list:\n",
    "\n",
    "def find_unique_items(data):\n",
    "    uniques = []\n",
    "\n",
    "    for item in data:\n",
    "        if item not in uniques:\n",
    "            uniques.append(item)\n",
    "\n",
    "    return uniques\n",
    "Let's compare the above function to using the set data type for collecting unique items.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use the provided function to collect the unique Pokémon in the names list. Save this as uniq_names_func.\n",
    "Use a set data type to collect the unique Pokémon in the names list. Save this as uniq_names_set.\n",
    "Use the most efficient approach for gathering unique items to collect the unique Pokémon types (from the primary_types list) and Pokémon generations (from the generations list)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58687578",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use find_unique_items() to collect unique Pokémon names\n",
    "uniq_names_func = find_unique_items(names)\n",
    "print(len(uniq_names_func))\n",
    "\n",
    "# Convert the names list to a set to collect unique Pokémon names\n",
    "uniq_names_set = set(names)\n",
    "print(len(uniq_names_set))\n",
    "\n",
    "# Check that both unique collections are equivalent\n",
    "print(sorted(uniq_names_func) == sorted(uniq_names_set))\n",
    "\n",
    "# Use the best approach to collect unique primary types and generations\n",
    "uniq_types = set(primary_types) \n",
    "uniq_gens = set(generations)\n",
    "print(uniq_types, uniq_gens, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eba5d67",
   "metadata": {},
   "source": [
    "Gathering Pokémon without a loop\n",
    "A list containing 720 Pokémon has been loaded into your session as poke_names. Another list containing each Pokémon's corresponding generation has been loaded as poke_gens.\n",
    "\n",
    "A for loop has been created to filter the Pokémon that belong to generation one or two, and collect the number of letters in each Pokémon's name:\n",
    "\n",
    "gen1_gen2_name_lengths_loop = []\n",
    "\n",
    "for name,gen in zip(poke_names, poke_gens):\n",
    "    if gen < 3:\n",
    "        name_length = len(name)\n",
    "        poke_tuple = (name, name_length)\n",
    "        gen1_gen2_name_lengths_loop.append(poke_tuple)\n",
    "Instructions\n",
    "\n",
    "Eliminate the above for loop using list comprehension and the map() function:\n",
    "Use list comprehension to collect each Pokémon that belongs to generation 1 or generation 2. Save this as gen1_gen2_pokemon.\n",
    "Use the map() function to collect the number of letters in each Pokémon's name within the gen1_gen2_pokemon list. Save this map object as name_lengths_map.\n",
    "Combine gen1_gen2_pokemon and name_length_map into a list called gen1_gen2_name_lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bc0c60b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collect Pokémon that belong to generation 1 or generation 2\n",
    "gen1_gen2_pokemon = [name for name,gen in zip(poke_names, poke_gens) if gen < 3]\n",
    "\n",
    "# Create a map object that stores the name lengths\n",
    "name_lengths_map = map(len, gen1_gen2_pokemon)\n",
    "\n",
    "# Combine gen1_gen2_pokemon and name_lengths_map into a list\n",
    "gen1_gen2_name_lengths = [*zip(gen1_gen2_pokemon, name_lengths_map)]\n",
    "\n",
    "print(gen1_gen2_name_lengths_loop[:5])\n",
    "print(gen1_gen2_name_lengths[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b41ec4",
   "metadata": {},
   "source": [
    "Pokémon totals and averages without a loop\n",
    "A list of 720 Pokémon has been loaded into your session called names. Each Pokémon's corresponding statistics has been loaded as a NumPy array called stats. Each row of stats corresponds to a Pokémon in names and each column represents an individual Pokémon stat (HP, Attack, Defense, Special Attack, Special Defense, and Speed respectively.)\n",
    "\n",
    "You want to gather each Pokémon's total stat value (i.e., the sum of each row in stats) and each Pokémon's average stat value (i.e., the mean of each row in stats) so that you find the strongest Pokémon.\n",
    "\n",
    "The below for loop was written to collect these values:\n",
    "\n",
    "poke_list = []\n",
    "\n",
    "for pokemon,row in zip(names, stats):\n",
    "    total_stats = np.sum(row)\n",
    "    avg_stats = np.mean(row)\n",
    "    poke_list.append((pokemon, total_stats, avg_stats))\n",
    "Instructions\n",
    "\n",
    "Replace the above for loop using NumPy:\n",
    "Create a total stats array (total_stats_np) using the .sum() method and specifying the correct axis.\n",
    "Create an average stats array (avg_stats_np) using the .mean() method and specifying the correct axis.\n",
    "Create a final output list (poke_list_np) by combining the names list, the total_stats_np array, and the avg_stats_np array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd928a4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a total stats array\n",
    "total_stats_np = stats.sum(axis=1)\n",
    "\n",
    "# Create an average stats array\n",
    "avg_stats_np = stats.mean(axis=1)\n",
    "\n",
    "# Combine names, total_stats_np, and avg_stats_np into a list\n",
    "poke_list_np = [*zip(names, total_stats_np, avg_stats_np)]\n",
    "\n",
    "print(poke_list_np == poke_list, '\\n')\n",
    "print(poke_list_np[:3])\n",
    "print(poke_list[:3], '\\n')\n",
    "top_3 = sorted(poke_list_np, key=lambda x: x[1], reverse=True)[:3]\n",
    "print('3 strongest Pokémon:\\n{}'.format(top_3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "088e6d90",
   "metadata": {},
   "source": [
    "One-time calculation loop\n",
    "A list of integers that represents each Pokémon's generation has been loaded into your session called generations. You'd like to gather the counts of each generation and determine what percentage each generation accounts for out of the total count of integers.\n",
    "\n",
    "The below loop was written to accomplish this task:\n",
    "\n",
    "for gen,count in gen_counts.items():\n",
    "    total_count = len(generations)\n",
    "    gen_percent = round(count / total_count * 100, 2)\n",
    "    print(\n",
    "      'generation {}: count = {:3} percentage = {}'\n",
    "      .format(gen, count, gen_percent)\n",
    "    )\n",
    "Let's make this loop more efficient by moving a one-time calculation outside the loop.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Import Counter from the collections module.\n",
    "Use Counter() to collect the count of each generation from the generations list. Save this as gen_counts.\n",
    "Write a better for loop that places a one-time calculation outside (above) the loop. Use the exact same syntax as the original for loop (simply copy and paste the one-time calculation above the loop)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b32b6148",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Counter\n",
    "from collections import Counter\n",
    "\n",
    "# Collect the count of each generation\n",
    "gen_counts = Counter(generations)\n",
    "\n",
    "# Improve for loop by moving one calculation above the loop\n",
    "total_count = len(generations)\n",
    "for gen,count in gen_counts.items():\n",
    "    gen_percent = round(count/ total_count *100, 2)\n",
    "    print('generation {}: count = {:3} percentage = {}'\n",
    "          .format(gen, count, gen_percent))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f9d2c55",
   "metadata": {},
   "source": [
    "Holistic conversion loop\n",
    "A list of all possible Pokémon types has been loaded into your session as pokemon_types. It's been printed in the console for convenience.\n",
    "\n",
    "You'd like to gather all the possible pairs of Pokémon types. You want to store each of these pairs in an individual list with an enumerated index as the first element of each list. This allows you to see the total number of possible pairs and provides an indexed label for each pair.\n",
    "\n",
    "The below loop was written to accomplish this task:\n",
    "\n",
    "enumerated_pairs = []\n",
    "\n",
    "for i,pair in enumerate(possible_pairs, 1):\n",
    "    enumerated_pair_tuple = (i,) + pair\n",
    "    enumerated_pair_list = list(enumerated_pair_tuple)\n",
    "    enumerated_pairs.append(enumerated_pair_list)\n",
    "Let's make this loop more efficient using a holistic conversion.\n",
    "\n",
    "Instructions\n",
    "\n",
    "combinations from the itertools module has been loaded into your session. Use it to create a list called possible_pairs that contains all possible pairs of Pokémon types (each pair has 2 Pokémon types).\n",
    "Create an empty list called enumerated_tuples above the for loop.\n",
    "Within the for loop, append each enumerated_pair_tuple to the empty list you created in the above step.\n",
    "Use a built-in function to convert each tuple in enumerated_tuples to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72fad4e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collect all possible pairs using combinations()\n",
    "possible_pairs = [*combinations(pokemon_types, 2)]\n",
    "\n",
    "# Create an empty list called enumerated_tuples\n",
    "enumerated_tuples = []\n",
    "\n",
    "# Append each enumerated_pair_tuple to the empty list above\n",
    "for i,pair in enumerate(possible_pairs, 1):\n",
    "    enumerated_pair_tuple = (i,) + pair\n",
    "    enumerated_tuples.append(enumerated_pair_tuple)\n",
    "\n",
    "# Convert all tuples in enumerated_tuples to a list\n",
    "enumerated_pairs = [*map(list, enumerated_tuples)]\n",
    "print(enumerated_pairs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9cc6114",
   "metadata": {},
   "source": [
    "Bringing it all together: Pokémon z-scores\n",
    "A list of 720 Pokémon has been loaded into your session as names. Each Pokémon's corresponding Health Points is stored in a NumPy array called hps. You want to analyze the Health Points using the z-score to see how many standard deviations each Pokémon's HP is from the mean of all HPs.\n",
    "\n",
    "The below code was written to calculate the HP z-score for each Pokémon and gather the Pokémon with the highest HPs based on their z-scores:\n",
    "\n",
    "poke_zscores = []\n",
    "\n",
    "for name,hp in zip(names, hps):\n",
    "    hp_avg = hps.mean()\n",
    "    hp_std = hps.std()\n",
    "    z_score = (hp - hp_avg)/hp_std\n",
    "    poke_zscores.append((name, hp, z_score))\n",
    "highest_hp_pokemon = []\n",
    "\n",
    "for name,hp,zscore in poke_zscores:\n",
    "    if zscore > 2:\n",
    "        highest_hp_pokemon.append((name, hp, zscore))\n",
    "Instructions\n",
    "\n",
    "Use NumPy to eliminate the for loop used to create the z-scores.\n",
    "Then, combine the names, hps, and z_scores objects together into a list called poke_zscores2.\n",
    "Use list comprehension to replace the for loop used to collect Pokémon with the highest HPs based on their z-score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c670d0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the total HP avg and total HP standard deviation\n",
    "hp_avg = hps.mean()\n",
    "hp_std = hps.std()\n",
    "\n",
    "# Use NumPy to eliminate the previous for loop\n",
    "z_scores = (hps - hp_avg)/hp_std\n",
    "\n",
    "# Combine names, hps, and z_scores\n",
    "poke_zscores2 = [*zip(names, hps, z_scores)]\n",
    "print(*poke_zscores2[:3], sep='\\n')\n",
    "\n",
    "# Use list comprehension with the same logic as the highest_hp_pokemon code block\n",
    "highest_hp_pokemon2 = [(names, hps, z_scores) for names,hps,z_scores in poke_zscores2 if z_scores > 2]\n",
    "print(*highest_hp_pokemon2, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faaf142a",
   "metadata": {},
   "source": [
    "Iterating with .iterrows()\n",
    "In the video, we discussed that .iterrows() returns each DataFrame row as a tuple of (index, pandas Series) pairs. But, what does this mean? Let's explore with a few coding exercises.\n",
    "\n",
    "A pandas DataFrame has been loaded into your session called pit_df. This DataFrame contains the stats for the Major League Baseball team named the Pittsburgh Pirates (abbreviated as 'PIT') from the year 2008 to the year 2012. It has been printed into your console for convenience.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use .iterrows() to loop over pit_df and print each row. Save the first item from .iterrows() as i and the second as row.\n",
    "Add two lines to the loop: one before print(row) to print each index variable and one after to print each row's type.\n",
    "Instead of using i and row in the for statement to store the output of .iterrows(), use one variable named row_tuple.\n",
    "Add a line in the for loop to print the type of each row_tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54c0bb2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterate over pit_df and print each index variable and then each row\n",
    "for i,row in pit_df.iterrows():\n",
    "    print(i)\n",
    "    print(row)\n",
    "    print(type(row))\n",
    "    \n",
    "# Use one variable instead of two to store the result of .iterrows()\n",
    "# Print the row and type of each row\n",
    "for row_tuple in pit_df.iterrows():\n",
    "    print(row_tuple)\n",
    "    print(type(row_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f7e4e1",
   "metadata": {},
   "source": [
    "Run differentials with .iterrows()\n",
    "You've been hired by the San Francisco Giants as an analyst—congrats! The team's owner wants you to calculate a metric called the run differential for each season from the year 2008 to 2012. This metric is calculated by subtracting the total number of runs a team allowed in a season from the team's total number of runs scored in a season. 'RS' means runs scored and 'RA' means runs allowed.\n",
    "\n",
    "The below function calculates this metric:\n",
    "\n",
    "def calc_run_diff(runs_scored, runs_allowed):\n",
    "\n",
    "    run_diff = runs_scored - runs_allowed\n",
    "\n",
    "    return run_diff\n",
    "A DataFrame has been loaded into your session as giants_df and printed into the console. Let's practice using .iterrows() to add a run differential column to this DataFrame.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Create an empty list called run_diffs that will be used to store the run differentials you will calculate.\n",
    "Write a for loop that uses .iterrows() to loop over giants_df and collects each row's runs scored and runs allowed.\n",
    "Add a line to the for loop that uses the provided function to calculate each row's run differential.\n",
    "Add a line to the loop that appends each row's run differential to the run_diffs list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da63e88d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an empty list to store run differentials\n",
    "run_diffs = []\n",
    "\n",
    "# Write a for loop and collect runs allowed and runs scored for each row\n",
    "for i,row in giants_df.iterrows():\n",
    "    runs_scored = row['RS']\n",
    "    runs_allowed = row['RA']\n",
    "    \n",
    "    # Use the provided function to calculate run_diff for each row\n",
    "    run_diff = calc_run_diff(runs_scored, runs_allowed)\n",
    "    \n",
    "    # Append each run differential to the output list\n",
    "    run_diffs.append(run_diff)\n",
    "\n",
    "giants_df['RD'] = run_diffs\n",
    "print(giants_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1a9dd99",
   "metadata": {},
   "source": [
    "Iterating with .itertuples()\n",
    "Remember, .itertuples() returns each DataFrame row as a special data type called a namedtuple. You can look up an attribute within a namedtuple with a special syntax. Let's practice working with namedtuples.\n",
    "\n",
    "A pandas DataFrame has been loaded into your session called rangers_df. This DataFrame contains the stats ('Team', 'League', 'Year', 'RS', 'RA', 'W', 'G', and 'Playoffs') for the Major League baseball team named the Texas Rangers (abbreviated as 'TEX').\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use .itertuples() to loop over rangers_df and print each row.\n",
    "Loop over rangers_df with .itertuples() and save each row's Index, Year, and Wins (W) attribute as i, year, and wins.\n",
    "Now, loop over rangers_df and print these values only for those rows where the Rangers made the playoffs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab4b51ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loop over the DataFrame and print each row\n",
    "for s in rangers_df.itertuples():\n",
    "    print(s)\n",
    "\n",
    "# Loop over the DataFrame and print each row's Index, Year and Wins (W)\n",
    "for row in rangers_df.itertuples():\n",
    "    i = row.Index\n",
    "    year = row.Year\n",
    "    wins = row.W\n",
    "    print(i, year, wins)\n",
    "\n",
    "# Check if rangers made Playoffs (1 means yes; 0 means no)\n",
    "if row.Playoffs == 1:\n",
    "    print(i, year, wins)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae82988",
   "metadata": {},
   "source": [
    "Run differentials with .itertuples()\n",
    "The New York Yankees have made a trade with the San Francisco Giants for your analyst contract— you're a hot commodity! Your new boss has seen your work with the Giants and now wants you to do something similar with the Yankees data. He'd like you to calculate run differentials for the Yankees from the year 1962 to the year 2012 and find which season they had the best run differential.\n",
    "\n",
    "You've remembered the function you used when working with the Giants and quickly write it down:\n",
    "\n",
    "def calc_run_diff(runs_scored, runs_allowed):\n",
    "\n",
    "    run_diff = runs_scored - runs_allowed\n",
    "\n",
    "    return run_diff\n",
    "Let's use .itertuples() to loop over the yankees_df DataFrame (which has been loaded into your session) and calculate run differentials.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use .itertuples() to loop over yankees_df and grab each row's runs scored and runs allowed values.\n",
    "Calculate each row's run differential using calc_run_diff(). Be sure to append each row's run differential to run_diffs.\n",
    "Append a new column called 'RD' to the yankees_df DataFrame that contains the run differentials you calculated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eca83930",
   "metadata": {},
   "outputs": [],
   "source": [
    "run_diffs = []\n",
    "\n",
    "# Loop over the DataFrame and calculate each row's run differential\n",
    "for row in yankees_df.itertuples():\n",
    "    \n",
    "    runs_scored = row.RS\n",
    "    runs_allowed = row.RA\n",
    "\n",
    "    run_diff = calc_run_diff(runs_scored, runs_allowed)\n",
    "    \n",
    "    run_diffs.append(run_diff)\n",
    "\n",
    "# Append new column\n",
    "yankees_df['RD'] = run_diffs\n",
    "print(yankees_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2cfa66a",
   "metadata": {},
   "source": [
    "Analyzing baseball stats with .apply()\n",
    "The Tampa Bay Rays want you to analyze their data.\n",
    "\n",
    "They'd like the following metrics:\n",
    "\n",
    "The sum of each column in the data\n",
    "The total amount of runs scored in a year ('RS' + 'RA' for each year)\n",
    "The 'Playoffs' column in text format rather than using 1's and 0's\n",
    "The below function can be used to convert the 'Playoffs' column to text:\n",
    "\n",
    "def text_playoffs(num_playoffs): \n",
    "    if num_playoffs == 1:\n",
    "        return 'Yes'\n",
    "    else:\n",
    "        return 'No' \n",
    "Use .apply() to get these metrics. A DataFrame (rays_df) has been loaded and printed to the console. This DataFrame is indexed on the 'Year' column.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Apply sum() to each column of rays_df to collect the sum of each column. Be sure to specify the correct axis.\n",
    "Apply sum() to each row of rays_df, only looking at the 'RS' and 'RA' columns, and specify the correct axis.\n",
    "Use .apply() and a lambda function to apply text_playoffs() to each row's 'Playoffs' value of the rays_df DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93a11be0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gather sum of all columns\n",
    "stat_totals = rays_df.apply(sum, axis=0)\n",
    "print(stat_totals)\n",
    "\n",
    "# Gather total runs scored in all games per year\n",
    "total_runs_scored = rays_df[['RS', 'RA']].apply(sum, axis=1)\n",
    "print(total_runs_scored)\n",
    "\n",
    "# Convert numeric playoffs to text by applying text_playoffs()\n",
    "textual_playoffs = rays_df.apply(lambda row: text_playoffs(row['Playoffs']), axis=1)\n",
    "print(textual_playoffs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26eaf3fd",
   "metadata": {},
   "source": [
    "Settle a debate with .apply()\n",
    "Word has gotten to the Arizona Diamondbacks about your awesome analytics skills. They'd like for you to help settle a debate amongst the managers. One manager claims that the team has made the playoffs every year they have had a win percentage of 0.50 or greater. Another manager says this is not true.\n",
    "\n",
    "Let's use the below function and the .apply() method to see which manager is correct.\n",
    "\n",
    "def calc_win_perc(wins, games_played):\n",
    "    win_perc = wins / games_played\n",
    "    return np.round(win_perc,2)\n",
    "A DataFrame named dbacks_df has been loaded into your session.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Print the first five rows of the dbacks_df DataFrame to see what the data looks like.\n",
    "Create a pandas Series called win_percs by applying the calc_win_perc() function to each row of the DataFrame with a lambda function.\n",
    "Create a new column in dbacks_df called WP that contains the win percentages you calculated in the above step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92f9c029",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display the first five rows of the DataFrame\n",
    "print(dbacks_df.head())\n",
    "\n",
    "# Create a win percentage Series \n",
    "win_percs = dbacks_df.apply(lambda row: calc_win_perc(row['W'], row['G']), axis=1)\n",
    "print(win_percs, '\\n')\n",
    "\n",
    "# Append a new column to dbacks_df\n",
    "dbacks_df['WP'] = win_percs\n",
    "print(dbacks_df, '\\n')\n",
    "\n",
    "# Display dbacks_df where WP is greater than 0.50\n",
    "print(dbacks_df[dbacks_df['WP'] >= 0.50])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e892308",
   "metadata": {},
   "source": [
    "Replacing .iloc with underlying arrays\n",
    "Now that you have a better grasp on a DataFrame's internals let's update one of your previous analyses to leverage a DataFrame's underlying arrays. You'll revisit the win percentage calculations you performed row by row with the .iloc method:\n",
    "\n",
    "def calc_win_perc(wins, games_played):\n",
    "    win_perc = wins / games_played\n",
    "    return np.round(win_perc,2)\n",
    "\n",
    "win_percs_list = []\n",
    "\n",
    "for i in range(len(baseball_df)):\n",
    "    row = baseball_df.iloc[i]\n",
    "\n",
    "    wins = row['W']\n",
    "    games_played = row['G']\n",
    "\n",
    "    win_perc = calc_win_perc(wins, games_played)\n",
    "\n",
    "    win_percs_list.append(win_perc)\n",
    "\n",
    "baseball_df['WP'] = win_percs_list\n",
    "Let's update this analysis to use arrays instead of the .iloc method. A DataFrame (baseball_df) has been loaded into your session.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use the right method to collect the underlying 'W' and 'G' arrays of baseball_df and pass them directly into the calc_win_perc() function. Store the result as a variable called win_percs_np.\n",
    "Create a new column in baseball_df called 'WP' that contains the win percentages you just calculated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8670f59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the W array and G array to calculate win percentages\n",
    "win_percs_np = calc_win_perc(baseball_df['W'].values, baseball_df['G'].values)\n",
    "\n",
    "# Append a new column to baseball_df that stores all win percentages\n",
    "baseball_df['WP'] = win_percs_np\n",
    "\n",
    "print(baseball_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b8d94a",
   "metadata": {},
   "source": [
    "Bringing it all together: Predict win percentage\n",
    "A pandas DataFrame (baseball_df) has been loaded into your session. For convenience, a dictionary describing each column within baseball_df has been printed into your console. You can reference these descriptions throughout the exercise.\n",
    "\n",
    "You'd like to attempt to predict a team's win percentage for a given season by using the team's total runs scored in a season ('RS') and total runs allowed in a season ('RA') with the following function:\n",
    "\n",
    "def predict_win_perc(RS, RA):\n",
    "    prediction = RS ** 2 / (RS ** 2 + RA ** 2)\n",
    "    return np.round(prediction, 2)\n",
    "Let's compare the approaches you've learned to calculate a predicted win percentage for each season (or row) in your DataFrame.\n",
    "\n",
    "Instructions\n",
    "\n",
    "Use a for loop and .itertuples() to predict the win percentage for each row of baseball_df with the predict_win_perc() function. Save each row's predicted win percentage as win_perc_pred and append each to the win_perc_preds_loop list.\n",
    "Apply predict_win_perc() to each row of the baseball_df DataFrame using a lambda function. Save the predicted win percentage as win_perc_preds_apply.\n",
    "Calculate the predicted win percentages by passing the underlying 'RS' and 'RA' arrays from baseball_df into predict_win_perc(). Save these predictions as win_perc_preds_np."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "babcd31f",
   "metadata": {},
   "outputs": [],
   "source": [
    "win_perc_preds_loop = []\n",
    "\n",
    "# Use a loop and .itertuples() to collect each row's predicted win percentage\n",
    "for row in baseball_df.itertuples():\n",
    "    runs_scored = row.RS\n",
    "    runs_allowed = row.RA\n",
    "    win_perc_pred = predict_win_perc(runs_scored, runs_allowed)\n",
    "    win_perc_preds_loop.append(win_perc_pred)\n",
    "\n",
    "# Apply predict_win_perc to each row of the DataFrame\n",
    "win_perc_preds_apply = baseball_df.apply(lambda row: predict_win_perc(row['RS'], row['RA']), axis=1)\n",
    "\n",
    "# Calculate the win percentage predictions using NumPy arrays\n",
    "win_perc_preds_np = predict_win_perc(baseball_df['RS'].values, baseball_df['RA'].values)\n",
    "baseball_df['WP_preds'] = win_perc_preds_np\n",
    "print(baseball_df.head())"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}