03-03_list_comprehensions_functions_and_scope.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on content by Wes McKinney"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List comprehensions\n",
    "\n",
    "List comprehensions allow us to create new lists concisely based on an existing collection\n",
    "\n",
    "They take the form:\n",
    "\n",
    "`[expr for val in collection if condition]`\n",
    "\n",
    "This is basically equivalent to the following loop:\n",
    "\n",
    "`result = []\n",
    "for val in collection:\n",
    "    if condition:\n",
    "        result.append(expr)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a list of the squares \n",
    "[x**2 for x in range(1,11)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([x**2 for x in range(1,11)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 9, 25, 49, 81]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# square only the odd numbers\n",
    "[x**2 for x in range(1,11) if x % 2 == 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BAT', 'CAR', 'DOVE', 'PYTHON']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# take a list of strings, and write the words that are over 2 characters long in uppercase.\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']\n",
    "[x.upper() for x in strings if len(x) > 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create a list comprehension from any iterable (list, tuple, string, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 6, 3, 2, 5, 7]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# extract the digits from a string\n",
    "string = \"Hello 963257 World\"\n",
    "[int(x) for x in string if x.isdigit()]\n",
    "# for x in string, will look at each character individually\n",
    "# if x is a digit, then convert it using int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iterate over a dictionary's items\n",
    "d = {'a':'apple', 'b':'banana', 'c':'cookie'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'apple'), ('b', 'banana'), ('c', 'cookie')]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(d.items())  # recall what dict.items() returns: a list of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a is for apple', 'c is for cookie']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[key + ' is for ' + value for key, value in d.items() if key != 'b' ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dict comprehension looks like this:\n",
    "\n",
    "`dict_comp = {key-expr : value-expr for value in collection if condition}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look at the list `strings` from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Apple': 5, 'Mango': 5, 'Banana': 6, 'Cherry': 6}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a dictionary, where the key is the word capitalized, and the value is the length of the word\n",
    "fruits = ['apple', 'mango', 'banana','cherry']\n",
    "{f.capitalize():len(f) for f in fruits}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a dictionary where the key is the index, and the value is the string in the strings list.\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'as'), (2, 'bat'), (3, 'car'), (4, 'dove'), (5, 'python')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(strings))  # enumerate produces a collection of tuples, with index and value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'a', 1: 'as', 2: 'bat', 3: 'car', 4: 'dove', 5: 'python'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index_map = {index:val for index, val in enumerate(strings)}\n",
    "index_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# note that enumerate returns tuples in the order (index, val)\n",
    "# in the creation of a dictionary, you can swap those positions\n",
    "# and even apply functions to them\n",
    "\n",
    "# We create a dictionary where the key is the string, and the value is the index in the strings list.\n",
    "loc_mapping = {val : index for index, val in enumerate(strings)}\n",
    "loc_mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-a566f0150b5c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mindex_map\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'a'"
     ]
    }
   ],
   "source": [
    "index_map['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loc_mapping['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5, 0: 'a', 1: 'as', 2: 'bat', 3: 'car', 4: 'dove', 5: 'python'}\n"
     ]
    }
   ],
   "source": [
    "# combine dictionaries with kwargs (to be covered later)\n",
    "dd = {**loc_mapping, **index_map}\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 0,\n",
       " 'as': 1,\n",
       " 'bat': 2,\n",
       " 'car': 3,\n",
       " 'dove': 4,\n",
       " 'python': 5,\n",
       " 0: 'a',\n",
       " 1: 'as',\n",
       " 2: 'bat',\n",
       " 3: 'car',\n",
       " 4: 'dove',\n",
       " 5: 'python'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# even better... use dict.update(). This modifies the dictionary in place\n",
    "loc_mapping.update(index_map)\n",
    "loc_mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prompting the user for input\n",
    "\n",
    "You can prompt the user for input with the function `input()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Miles\n",
      "Hello, Miles\n"
     ]
    }
   ],
   "source": [
    "name = input()\n",
    "print('Hello, ' + name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 0 9\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "name = input()\n",
    "print(type(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! What is your name?\n",
      "Miles\n",
      "Hi Miles, I am thinking of a number between 1 and 20. You have up to 6 guesses.\n",
      "Take a guess.\n",
      "10\n",
      "Your guess is too low.\n",
      "Take a guess.\n",
      "15\n",
      "Your guess is too low.\n",
      "Take a guess.\n",
      "18\n",
      "Your guess is too low.\n",
      "Take a guess.\n",
      "19\n",
      "Your guess is too low.\n",
      "Take a guess.\n",
      "20\n",
      "Good job, Miles! You guessed my number in 5 guesses!\n"
     ]
    }
   ],
   "source": [
    "# This is a Guess the Number game.\n",
    "# adapted from Invent Your Own Computer Games with Python by Al Sweigart\n",
    "import numpy as np\n",
    "\n",
    "guessesTaken = 0\n",
    "\n",
    "print('Hello! What is your name?')\n",
    "myName = input()\n",
    "\n",
    "number = np.random.randint(1, 21)\n",
    "print('Hi ' + myName + ', I am thinking of a number between 1 and 20. You have up to 6 guesses.')\n",
    "\n",
    "for guessesTaken in range(6):\n",
    "    print('Take a guess.')\n",
    "    guess = input()\n",
    "    guess = int(guess) # convert the string into an integer.\n",
    "        # If the user inputs something that can't be converted, it will produce an error\n",
    "\n",
    "    if guess < number:\n",
    "        print('Your guess is too low.')\n",
    "\n",
    "    if guess > number:\n",
    "        print('Your guess is too high.')\n",
    "\n",
    "    if guess == number:\n",
    "        break\n",
    "\n",
    "if guess == number:\n",
    "    guessesTaken = str(guessesTaken + 1)\n",
    "    print('Good job, ' + myName + '! You guessed my number in ' +  \n",
    "      guessesTaken + ' guesses!')\n",
    "\n",
    "if guess != number:\n",
    "    number = str(number)\n",
    "    print('Nope. The number I was thinking of was ' + number + '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions and scope\n",
    "\n",
    "If python can't find a variable in the functions body, it will look for it in the next higher scope. Each function has a parent scope, which is where the function is defined.\n",
    "\n",
    "Variables inside functions only exist inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 1)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 2  # changing y to 2, only affects the value inside the function\n",
    "    return(x,y,z)  # it does not find x or z in the local environment, so it searches the higher scope\n",
    "\n",
    "print(f())\n",
    "print(x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "# g is defined inside f\n",
    "# function f returns the value of g()\n",
    "# g() uses z = 3, can't find x, or y\n",
    "# it searches the higher scope f() for x and y\n",
    "# is uses f's value of y = 2\n",
    "# it uses global x = 1\n",
    "\n",
    "def f():\n",
    "    y = 2\n",
    "    def g():\n",
    "        z = 3\n",
    "        return(x, y, z) \n",
    "    return(g()) \n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 3)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "# g is defined in the global environment\n",
    "# function f returns the value of g()\n",
    "# g() uses z = 3, can't find x, or y\n",
    "# it searches the global environment for x and y because g is defined in the global environment\n",
    "# it uses global x = 1, and y = 1\n",
    "\n",
    "def g():\n",
    "    z = 3\n",
    "    return(x, y, z)\n",
    "\n",
    "def f():\n",
    "    y = 2\n",
    "    return(g()) \n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 1 3\n"
     ]
    }
   ],
   "source": [
    "# keyword global gives the function access to the value in the global environment\n",
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 2\n",
    "    def g():\n",
    "        global z  # calling global, gives g access to the global value of z\n",
    "        z = 3     # will assign 3 to the global variable z\n",
    "        return(x, y, z) \n",
    "    return(g()) \n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 3)\n",
      "1 1 1\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def g():\n",
    "    z = 3\n",
    "    return(x, y, z)\n",
    "\n",
    "def f():\n",
    "    global y\n",
    "    y = 2\n",
    "    return(g()) \n",
    "\n",
    "print(g()) # when we first run g(), it uses the global values of x and y, but the local value of z\n",
    "# the local value of z does not affect the globals value of z\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 2 1\n"
     ]
    }
   ],
   "source": [
    "print(f())  # when we run f(), the global value of y is changed\n",
    "# it calls g(), which uses its own local value of z = 3,\n",
    "# and uses the global value of y, which has been changed\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1 2 1\n"
     ]
    }
   ],
   "source": [
    "print(g())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p, q = 1, 1\n",
    "\n",
    "def f():\n",
    "    global s   # will create s in the global\n",
    "    s = 2\n",
    "    return(p, q, s)\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    global y\n",
    "    y = 4\n",
    "    def g():\n",
    "        global y \n",
    "        y = 10 \n",
    "        global z  \n",
    "        z = 3\n",
    "        return(x, y, z) \n",
    "    return(g()) \n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the keyword nonlocal will search the higher scope for the variable\n",
    "# and will modify it\n",
    "x, y, z = 1, 1, 1\n",
    "\n",
    "def f():\n",
    "    y = 4\n",
    "    def g():\n",
    "        nonlocal y  \n",
    "        y = 10  # affects the y defined inside f\n",
    "        global z  \n",
    "        z = 3\n",
    "        return(x, y, z)\n",
    "    print(x, y, z)  # this line is run before g() is called\n",
    "    return(g())  # when g() is called, y will be modified\n",
    "\n",
    "print(f())\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "p, q = 1, 1\n",
    "\n",
    "def f():\n",
    "    nonlocal r   # will return an error because r does not exist in the nonlocal environment\n",
    "    r = 2\n",
    "    return(p, q, r)\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python functions are objects themselves\n",
    "\n",
    "You can reference python functions as objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states = ['   Alabama ', 'Georgia!', 'Georgia', 'georgia', \n",
    "          'FlOrIda', 'south  carolina##', 'West virginia?']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re  # package for regular expressions\n",
    "\n",
    "# here is a function that applies a series of operations to clean up the strings\n",
    "\n",
    "def clean_strings1(strings):\n",
    "    result = []\n",
    "    for value in strings:\n",
    "        value = value.strip()  # strip whitespace\n",
    "        value = re.sub('[!#?]', '', value)  # substitutes the characters !, #, ? with ''\n",
    "        value = value.title()  # title case\n",
    "        result.append(value)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_strings1(states)  # when we apply the function to the list, it cleans up the messy text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we define a new function called remove_punctuation\n",
    "def remove_punctuation(value):\n",
    "    return re.sub('[!#?]', '', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a list of functions \n",
    "clean_ops = [str.strip, remove_punctuation, str.title]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just to demonstrate what these functions do...\n",
    "str.strip('    alabama    ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the function clean strings takes two arguments:\n",
    "# a list of strings\n",
    "# a list of functions\n",
    "def clean_strings2(strings, ops):\n",
    "    result = []\n",
    "    for value in strings:            # we loop over each string\n",
    "        for function in ops:         # for each string, we loop over the functions listed in ops\n",
    "            value = function(value)  # we update the value each time\n",
    "        result.append(value)         # we append the list results with the value\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_strings2(states, clean_ops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_strings2(states, [str.strip, remove_punctuation, str.upper, lambda x: re.sub('  ',' ', x)])  \n",
    "# I can provide a different list of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the python function map() takes in an function name as an argument and applies it to a list\n",
    "\n",
    "map(str.strip, states)  # map returns a map object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to see the contents of the map object, you can put it into a list:\n",
    "# map only allows you to specify one function\n",
    "list(map(str.strip, states))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lambda functions\n",
    "\n",
    "In one of the later examples, I created a lambda function\n",
    "\n",
    "A lambda function allows you to create and use a new short function without having to formally define it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I could define a function that replaces  two spaces with one space:\n",
    "def replace_space(x):\n",
    "    return(re.sub('  ', ' ', x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and then apply it to the strings:\n",
    "list(map(replace_space, states))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# however, because the code for the function is so short, it might be easier to just create\n",
    "# a quick function without a formal name. These 'anonymous' functions are also known as lambda functions\n",
    "\n",
    "list(map(lambda x: re.sub('  ',' ', x), states))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lambda functions are written in the form:\n",
    "\n",
    "`lambda argument1, argument2, etc: expression to return`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lambda functions can accept multiple arguments\n",
    "# if you use it with map, you'll need to provide a list for each argument\n",
    "list(map(lambda x, y: x + y, [1,2,3], [100,200,300]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}