如何在一行代码中解释filter和lambda的功能？

Question

number_plates = ["DV61 GGB",      #UK
                 "D31 EG 2A",     #F
                 "5314 10A02",    #F
                 "24TEG 5063",    #F
                 "TR09 TRE",      #UK
                 "524 WAL 75",    #F
                 "TR44 VCZ",      #UK
                 "FR52 SWD",      #UK
                 "100 GBS 12",    #F
                 "HG55 BPO"       #UK
                 ]

# Find the non-UK plates
pattern = "(?![A-Z]{2}\d{2}\s+[A-Z]{3}$)"
foreign_numbers = list(filter(lambda x: re.match(pattern, x), number_plates))

This is a part of my code. The foreign_numbers = list(filter(lambda x: re.match(pattern, x), number_plates)) has been done by someone else for me, and I know roughly that it puts number plates into a new list if it doesn't match the pattern of UK number plate structure. This is a task set by my teacher therefore I also need to explain different parts of code one by one.

My question is: What do filter and lambda do in foreign_numbers = list(filter(lambda x: re.match(pattern, x), number_plates)) that the foreign plates are placed in the new list because they don't match the pattern?

Answer 1

There are two parts to your question.

1. lambda is just a different way to write a function:

    def find_non_uk(x): return re.match(pattern, x) 

   is the same as :

    find_non_uk = lambda x: re.match(pattern, x) 

   lambda is rather limited in what you can do. It is essentially ilmited to one line and all has to be an expression. Using def , there are no such limitations. You can use multiple lines and statements in the function body.

2. filter applies the given function to each element of your list and returns only those elements of the list for which the return value is true. From the docstring:

   filter(function or None, iterable) --> filter object

   Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true.

You could write your line like this:

foreign_numbers = list(filter(find_non_uk, number_plates))

You need the outer list() to turn the iterator into a list.

If this seems too complicated and you know list comprehensions, use them:

pattern = re.compile("(?![A-Z]{2}\d{2}\s+[A-Z]{3}$)")
foreign_numbers = [x for x in number_plates if pattern.match(x)]

Answer 2

In list(filter(lambda x: re.match(pattern, x), number_plates)) , filter function itself returns a list of elements that passed the check (in this case matched regex pattern) -just like the filter we use to strain liquids to make sherbet. and list function converts it into list. So

foreign_numbers = list(filter(lambda x: re.match(pattern, x), number_plates)) is the code that separates matched numbers into a list called foreign_numbers

>>>print foreign_numbers
>>>['D31 EG 2A', '5314 10A02', '24TEG 5063', '524 WAL 75', '100 GBS 12']

The function of lambda is grab one by one element from number_plates list and passes to the re.match .

Answer 3

If you compile the pattern into a RegexObject , you don't have to create a lambda, as you can just use the object's match method:

pattern = re.compile("(?![A-Z]{2}\d{2}\s+[A-Z]{3}$)")
foreign_numbers = list(filter(pattern.match, number_plates))

The match method gets called for every number plate, and if it matches, filter will keep it.