The Map Method
The map()
method is a way to apply the effect of a function on every element in an iterable. It iterates over the iterable, and passes each element in turn into the function you provide it. Each of these return values are appended to a (new) list, which map()
returns.
Exercise 7.1: Make a custom map
Instructions
 Build a function called
my_map
that takes a function and an interable as arguments.  For this example, make the function it that map takes as an argument a function that takes something as an input, does something to it, and returns the changed element. Examples:
 It takes a number and returns the number squared
 It takes a string and returns the string reversed
 …etc.
 Your
my_map
function should iterate over your iterable, and pass each element into the function you gave it  It should compile the return values of that step into a new list, which it returns
Exercise 7.2
 Make a list of numbers:
NUMBERS = range(1, 100)
 Run this
numbers
through yourmy_map
function with an anonymous function which doubles each number  Print the output
Did all of this work?
Here’s my solution
Exercise 8
 Take this list of strings:
PICTURES = ["picture1", "georgi_paws_everywhere", "custom_wreath"]

Use your custom
my_map
to map the extension.jpg
on to the end of each of these strings 
Did you get it working? Here’s my solution
Exercise 9
 Make a new list of numbers:
numbers = range(4)
 Take this list of strings:
NAMES = ['Rebecca', 'Georgi', 'Reed', 'Thom Yorke']
 Use your
my_map
method to return a list of tuples, the first element of the tuple should be the number innumbers
 The second element in the tuple should be the name in
names
at the index of each number fromnumbers
 Does that make sense? An example tuple would be:
(0, 'Rebecca')
Hints:
 If using a lambda function confuses you, make a separate function

Tuples are immutable, so you’ll need to construct the tuple in that function (you can’t
append()
elements onto a tuple)  Did you get it working? Here’s my solution
The BuiltIn Map Function
map(function, iterable, …)
From the documentation:
Apply function to every item of iterable and return a list of the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be extended with None items. If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list.
To figure out what this does I played around with it, starting with this part:
If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list.
By passing in None
as the function value, it says “the identity function is assumed”. I don’t know what that means, but I tried giving it None
as the function, and giving it both NUMBERS
and NAMES
in the iterable list, and look what it did:
>>> NUMBERS = range(4)
>>> NAMES = ['Rebecca', 'Georgi', 'Reed', 'Thom Yorke']
>>>
>>> results = map(None, NUMBERS, NAMES) # None as the function, and added both iterables
>>> print results
[(0, 'Rebecca'), (1, 'Georgi'), (2, 'Reed'), (3, 'Thom Yorke')]
>>>
Well, that’s cool. Our custom map function certainly won’t do that. That takes care of Exercise 9. This seems like a really easy way to combine lists.
Now what about that first sentence:
If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel.
I tried this:
>>> NUMBERS = range(4)
>>> NAMES = ['Rebecca', 'Georgi', 'Reed', 'Thom Yorke']
>>>
>>> results = map(lambda x, y: (x, y), NUMBERS, NAMES)
>>> print results
[(0, 'Rebecca'), (1, 'Georgi'), (2, 'Reed'), (3, 'Thom Yorke')]
Then I tried this:
>>> NUMBERS = range(1, 5) # I changed this to be the numbers 1 through 4
>>> NAMES = ['Rebecca', 'Georgi', 'Reed', 'Thom Yorke']
>>> results = map(lambda x, y: x*y, NUMBERS, NAMES) # I changed this to multiply the values
>>> print results
['Rebecca', 'GeorgiGeorgi', 'ReedReedReed', 'Thom YorkeThom YorkeThom YorkeThom Yorke']
This means that map()
takes the first elements from both iterables, and feeds them into the function.
1 * 'Rebecca' = 'Rebecca'
Then it takes the second element from both iterables and feeds them into the function:
2 * 'Georgi' = 'GeorgiGeorgi'
Then:
3 * 'Reed' = 'ReedReedReed'
And then lots of Thom Yorke.
Before writing this I didn’t know that map()
could take None
as an argument for the function, or that it could take multiple iterables and work through them in parallel.
Thank you for reading this and learning with me!