Learn

In this exercise, we will see how we can combine the map() and filter() functions.

Conceptually, if you’re working with a collection of items and find yourself saying, “I need to map only values that have property x,” you will likely need to use map() and filter() together. in English, “I need to map filtered values” translates into Python like this:

map(mapping_function, filter(predicate, iterable))

Let’s take a look at an example.

We have a tuple representing the records of students in various math classes. The tuple will be structured in the following way: student(name, grade, course). As an example, student("Peter", 'B', 101) will represent a student named Peter who received a grade of B in a Math 101 course.

We want to register students who receive a grade of B or better in their respective math courses for a special advanced math course: Math 201. To create the record for the course, we will filter all students with grade B or higher and map their math course to 201.

The initial grade in the new tuple will contain the letter ‘X’ to represent that it is not yet defined because the student has not yet finished Math 101. We can do this in Python like so:

First, we create a namedtuple to represent a student:

from collections import namedtuple

# Create a class called student
student = namedtuple("student", ["name", "grade", "course_number"]) 

We then create records for the sample data:

# Create the records for the students in the form of tuples

peter = student("Peter", 'B', 101)
amanda = student("Amanda", 'C', 101 )
sarah = student("Sarah", 'A', 102)
lisa = student("Lisa", 'D', 101)
alex = student("Alex", 'A', 102)
maria = student("Maria", 'B', 101)
andrew = student("Andrew", 'C', 102)

math_class = (peter, amanda, sarah, lisa, alex, maria, andrew)

Finally, we use map() to create a new record for a student consisting of:

• their name
• the initial grade X
• the math course Math 201 only IF the student’s previous grade was B or above in their respective math course
math_201 = map(lambda s: student(s.name, 'X', 201), filter(lambda q: q.grade <= 'B', math_class))

print(tuple(math_201))

The line q.grade <= 'B' removes students with grades less than B. The <= appears because the character A is lower than B in the alphabet (how Python compares the characters).

The code “maps a filtered value”. Remember, that because map() returns an iterable, we use the tuple() function to generate all the values we need.

The output will be all the students who are eligible for Math 201:

(student("Peter, 'X', 201), student("Sarah",' X', 201), student("Alex",  'X', 201), student("Maria",  'X', 201))

### Instructions

1.

Given the tuple nums multiply values that are greater than 10 by two. Save your result as greater_than_10_doubled. Print your answer using the following line of code:

print(tuple(greater_than_10_doubled))
2.

Convert the following code from the imperative style to the declarative:

lst = []
for i in nums:
if i % 3 == 0:
lst.append(i)

for i in range(len(lst)):
lst[i] = lst[i] * 3

tuple(lst)

Here, nums represents the tuple provided in the workspace.

Save your result in a variable called functional_way. Print your answer using the following line of code:

print(tuple(functional_way))

If you get stuck, look over the hint.