Lambda

Loading...

From the course by Rice University

Python Data Analysis

140 оценки

Rice University

Python Data Analysis

140 оценки

Course 3 of 4 in the Specialization Introduction to Scripting in Python

This course will continue the introduction to Python programming that started with Python Programming Essentials and Python Data Representations. We'll learn about reading, storing, and processing tabular data, which are common tasks. We will also teach you about CSV files and Python's support for reading and writing them. CSV files are a generic, plain text file format that allows you to exchange tabular data between different programs. These concepts and skills will help you to further extend your Python programming knowledge and allow you to process more complex data. By the end of the course, you will be comfortable working with tabular data in Python. This will extend your Python programming expertise, enabling you to write a wider range of scripts using Python. This course uses Python 3. While most Python programs continue to use Python 2, Python 3 is the future of the Python programming language. This course uses basic desktop Python development environments, allowing you to run Python programs directly on your computer.

From the lesson

Organizing Data

This module will teach you how to sort data in Python. You will organize and analyze tabular data.

Advanced Sorting5:44

Meet the Instructors

Scott Rixner
Professor
Computer Science
Joe Warren
Professor
Computer Science

[MUSIC]

In this video, I'm going to introduce you to the concept of anonymous functions.

What is that?

Well, as the name implies,

they're functions that you write that have no name.

Normally, when we write a function, we say def and then the name of the function, and

then we continue from there.

And now that function has a name and

we can call it from anywhere by using that name.

An anonymous function, well we just write it inline in our code somewhere where we

need it and that's the only place it is.

And you can't refer to it ever again, because it has no name, right?

Now these are often called lambdas, and

in Python you use the keyword lambda to create them.

So let's take a look at what's going on here.

Now, you usually use lambda's when you're creating a function that you're just going

to pass to another function, and that's all you're going to do with it.

So first I want to introduce to you to a function called map,

which is a function that takes other functions as an argument.

So first let's create a list, and I'm going to use my shortcut here of range,

all right, and that gives me a list of numbers.

Then I'm going to define a function called square, and

all it does is take a number as an input, and return the square of that number.

Now I want to take my list of data and my square function, and I

want to apply the square function to every element in the list and create a new list.

So I basically want a list of squares.

Well, I'm sure you could do that with a loop, but

the function map allows us to do this is in an easier way.

Map takes at least two arguments.

The first argument always needs to be a function, so

I'm going to pass it square and then it can take sequences.

So I'll pass it data.

And what's going to happen here is it's going to call square

on every element of data and create a new list with the results of all these calls.

So let's run this and see what happens.

Well, it did what you might expect.

Or rather, it did exactly [LAUGH] what I said it was going to do.

It created a list of all the squares of the elements in the input list.

All right, well, where do the anonymous functions come in?

Well, you might notice here that I had to define that square function

simply to pass it to map.

Well, why bother?

Lambda's make that a little bit simpler.

So let's try and do exactly the same thing,

except this time I want to double all the numbers in the list.

So instead of defining yet another function simply so

I can pass it to map, let's use a lambda.

Now, here is the syntax of a lambda.

The keyword lambda is first, then the arguments to the function followed

by a colon, and then you are allowed to have a single expression.

So these are limited functions.

They can't have multiple lines of code.

You effectively can have one Python expression.

So num * 2 here is the expression that I want, and I don't need a return statement.

It basically evaluates the expression and that's what gets returned.

So I pass to map.

The first argument is this lambda, which is a function that takes a single argument

and returns twice the input argument, and then my data list.

So hopefully you know what's going to happen here.

It's going to create a list of doubles or a list of even numbers, 0, 2,

4, 6, and so on.

So hopefully you can see that this was somewhat valuable,

because I can just create the lambda exactly where I need it.

I do not have to define a function with all the associated overhead of doing so,

just so that I can pass my function to a single other function.

But you are limited in what you can do.

You can take more than one argument.

You can take as many arguments as you want, but

you can only evaluate one single expression.

All right, let's explore this a little bit further.

I want to create another list and

let's make this list a bunch of random numbers, okay?

I'm going to use what's called a list comprehension here.

And hopefully it is readily obvious what's happening.

I used the square brackets to tell Python that this is a list, and

then I'm using random.randrange.

Wait a minute, what's that, [LAUGH] all right?

Well, that's another function from the random module.

Randrange says pick a random integer in the range from the first number up to, but

not including, the second number.

So from 2 to num+3, what's num+3?

Well, I have for num in range (10).

So what's going to happen is range (10) creates all the numbers from 0 to 9,

assigns them each in turn to num, and

then evaluates random.randrange with that num and creates a new list.

So I'm going to have a 10 element list with 10 random numbers, and

each number's going to be between 2, and the input +3.

All right, let's see what we get out of this.

I got a bunch of random numbers.

That makes sense, it did exactly what I said it would.

If you're interested in list comprehensions,

I encourage you to read the Python documentation.

Now what I want to do is create a list

of tuples using the map function and a lambda.

So when I pass more arguments to map, what it does is it takes an element from

each of the inputs following the first function, and passes it to that function.

So now I have a lambda that takes two arguments, num1 and num2.

And evaluates the expression, that is a tuple containing num1 and

num2, and then I have two lists afterwards.

So it'll pull elements from each of those two lists to create these tuples,

giving me a list of tuples.

And that is, in fact, what I get, a list of tuples.

I want to use another lambda here to get a list that only

includes the minimum value from each of the input tuples.

So I have a lambda that takes a single argument that I've called pair.

And it takes the minimum of pair sub 0, and pair sub 1,

and it operates over the list tups.

When I map that, I'm going to get something I'm calling mins,

and so it should be the minimums.

Let's see if it actually works.

And so if we look at the tuples, the first tuple was 0, 2 and

the first element of my minimums list is 0.

The next tuple was 1, 2, the second element in my minimums list is 1.

Then we have 2, 4, we get a 2.

Then we have 3, 2, we get a 2, 4, 6, we get a 4 and so on.

Well, that seemed to work, okay?

So by using map and lambda, I can write relatively

complicated things in not too much code.

It's pretty compact and efficient.

I finally want to introduce you to another function like map that takes functions and

operates on sequences of data called filter.

The filter takes a function as its first argument and then a sequence,

just like map did.

But the difference here now is filter

creates a list that is potentially shorter than the input sequence.

It evaluates the function for each element in the input sequence,

and if the function returns true, it adds it to the output list.

If the function returns false, then it doesn't.

So you can see here, I have a lambda that takes pair as an input, and

it checks, is the second number less than the first number?

So if that's true, filter is going to put that element into the output list.

If it's not, then it's not going to.

Let's run this.

So you can see that my filtered tuples only ended up as a list of three tuples,

even though the input had ten, all right?

And if I expand this, you can see where they came from.

All of the other tuples happen to have their first elements

be smaller than the second element.

Now you've seen how you can create and use anonymous functions.

The key ideas here are you use the keyword lambda to define an anonymous function.

You can have as many arguments as you'd like, then a colon and

then a single Python expression,

and the function evaluates that Python expression and returns its value.

These are incredibly valuable when you simply need to create a quick function

that is a single expression that you want to pass to another function.

And so I showed you map and filter, both of which are very powerful functions for

operating on sequences of data, that are ideal places to be using lambdas.

Now there are many others, and we'll see one in the next video.

Ознакомьтесь с нашим каталогом

Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.

Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.

© Coursera Inc., 2018 Все права защищены.

Загрузить из App Store

Загрузить в Google Play