4 - Writing Efficient Python Code.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "1 - Writing Efficient Python Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## A taste of things to come\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Built-in practice: range()\n",
    "\n",
    "# Create a range object that goes from 0 to 5\n",
    "nums = range(0,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,13,2)]\n",
    "print(nums_list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Built-in practice: enumerate()\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Built-in practice: map()\n",
    "\n",
    "# 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 = [*names_map]\n",
    "\n",
    "# Print the list created above\n",
    "print(names_uppercase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Practice with NumPy arrays\n",
    "\n",
    "# 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)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Bringing it all together: Festivus!\n",
    "\n",
    "# Create a list of arrival times\n",
    "arrival_times = [*range(10,60,10)]\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Using %timeit: your turn!\n",
    "\n",
    "# Create a list of integers (0-50) using list comprehension\n",
    "%timeit 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",
    "%timeit nums_unpack = [*range(51)]\n",
    "print(nums_unpack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Using %timeit: formal name or literal syntax\n",
    "\n",
    "# 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": "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": [
    "## Using %mprun: Hero BMI\n",
    "\n",
    "def calc_bmi_lists(sample_indices, hts, wts):\n",
    "\n",
    "    # Gather sample heights and weights as lists\n",
    "    s_hts = [hts[i] for i in sample_indices]\n",
    "    s_wts = [wts[i] for i in sample_indices]\n",
    "\n",
    "    # Convert heights from cm to m and square with list comprehension\n",
    "    s_hts_m_sqr = [(ht / 100) ** 2 for ht in s_hts]\n",
    "\n",
    "    # Calculate BMIs as a list with list comprehension\n",
    "    bmis = [s_wts[i] / s_hts_m_sqr[i] for i in range(len(sample_indices))]\n",
    "\n",
    "    return bmis\n",
    "\n",
    "\n",
    "%mprun -f calc_bmi_lists(heroes, hts, wts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Bringing it all together: Star Wars profiling\n",
    "\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",
    "\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",
    "\n",
    "\n",
    "# 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))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "3 - Gaining efficiencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Combining Pokémon names and types\n",
    "\n",
    "# Combine names and primary_types\n",
    "names_type1 = [*zip(names, primary_types)]\n",
    "\n",
    "print(*names_type1[:5], sep='\\n')\n",
    "\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",
    "\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Counting Pokémon from a sample\n",
    "\n",
    "# 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[:1] 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Combinations of Pokémon\n",
    "\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Comparing Pokédexes\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Searching for Pokémon\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Gathering unique Pokémon\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Gathering Pokémon without a loop\n",
    "\n",
    "# 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])\n",
    "\n",
    "\n",
    "## List comprehension \n",
    "[(name, len(name)) for name,gen in zip(poke_names, poke_gens) if gen < 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Pokémon totals and averages without a loop\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## One-time calculation loop\n",
    "\n",
    "# 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",
    "\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Holistic conversion loop\n",
    "\n",
    "# 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",
    "# Add a line to 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_pair_list = list(enumerated_pair_tuple)\n",
    "    enumerated_tuples.append(enumerated_pair_list)\n",
    "\n",
    "# Convert all tuples in enumerated_tuples to a list\n",
    "enumerated_pairs = [*map(list, enumerated_tuples)]\n",
    "print(enumerated_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Bringing it all together: Pokémon z-scores\n",
    "\n",
    "# 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_pokemon = [(names, hps, z_scores) for names, hps, z_scores in poke_zscores2 if z_scores > 2]\n",
    "print(*highest_hp_pokemon, sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "4 - Basic pandas optimizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Iterating with .iterrows()\n",
    "\n",
    "# Iterate over pit_df and print each row\n",
    "for i, row in pit_df.iterrows():\n",
    "    print(row)\n",
    "    \n",
    "\n",
    "# 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",
    "    \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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Run differentials with .iterrows()\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Iterating with .itertuples()\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",
    "  \n",
    "  # Check if rangers made Playoffs (1 means yes; 0 means no)\n",
    "  if row.Playoffs == 1:\n",
    "    print(i, year, wins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Run differentials with .itertuples()\n",
    "\n",
    "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Analyzing baseball stats with .apply()\n",
    "\n",
    "# Gather sum of all columns\n",
    "stat_totals = rays_df.apply(sum, axis=0)\n",
    "print(stat_totals)\n",
    "\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\n",
    "textual_playoffs = rays_df.apply(lambda row: text_playoffs(row['Playoffs']), axis=1)\n",
    "print(textual_playoffs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Settle a debate with .apply()\n",
    "\n",
    "# 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Replacing .iloc with underlying arrays\n",
    "\n",
    "# Use the W array and G array to calculate win percentages\n",
    "%timeit 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Bringing it all together: Predict win percentage\n",
    "\n",
    "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())"
   ]
  },
  {
   "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": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf-gpu-2.0",
   "language": "python",
   "name": "tf_gpu2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}