This course will continue the introduction to Python programming that started with Python Programming Essentials. We'll learn about different data representations, including strings, lists, and tuples, that form the core of all Python programs. We will also teach you how to access files, which will allow you to store and retrieve data within your programs. These concepts and skills will help you to manipulate data and write more complex Python programs. By the end of the course, you will be able to write Python programs that can manipulate data stored in files. This will extend your Python programming expertise, enabling you to write a wide 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 introduces basic desktop Python development environments, allowing you to run Python programs directly on your computer. This choice enables a smooth transition from online development environments.
Iteration over Lists
Loading...
Del curso dictado por Rice University
Python Data Representations
334 calificaciones
De la lección
Basics of Lists
This module will teach you the basics of Python's list data type. Lists are used to hold a sequence of data within programs.
Conoce a los instructores
Scott RixnerProfessor
Computer Science
Joe WarrenProfessor
Computer Science
[MUSIC]
It is a very common operation to want to process every single element of an item in
a list.
Okay, so you want to loop over the entire list and do the same thing again and
again, but once for each item.
Maybe you want to print every item in a list.
Well, the process of repeating something over and
over in computer science is called iteration.
Okay, we're going to create a loop and
we're going to do the same thing for each element of the list.
Maybe you want to to go over the list and print every element.
Usually it's more complicated than that, but that gives you an idea.
So in this video, we're going to look at how you can iterate over lists.
Let's take a look at the function, print_items.
The objective of this function is to print every item of the list,
one item per line, okay?
And so it's going to iterate over the list and print each item.
So let's look at the syntax of a for loop, all right?
Well for loop starts with the keyword for, as you can see.
And then it has a variable name, and
in this case that variable name is item and says in and then the list, alist.
Okay, now in here is not the same as when we were checking to see if an item was in
a list, okay?
So Python is using the keyword in, in two different ways.
When it's in a statement that begins with a the keyword for, it means for
every item in a list.
That's the way to read that statement there.
And notice that it ends with a colon.
And in Python, every time something ends in the colon it means, hey,
after this there's going to be a block of code, and
that block of code is going to be indented, all right?
And so you can see the body of this loop is simply the statement that prints item.
So what's going to happen here is, the loop is going to go through every single
item of the list or every element of the list let's say, to avoid confusion.
And each element will be assigned to the variable item for
one execution of the body of the loop.
So the first time through,
item will be the list element at index zero, we will print it.
The second time through it'll be the list element at index one, we will print it and
so on.
Okay, so this allows us to repeat a block of code.
In this case it's just one line, print item, over and over and
over again, where there's a variable, in this case it's called item,
that holds each element of the list in turn, right?
So let's try this out, okay?
Let's go down here, okay?
We have two lists.
Numbers, which we create using range and converting that into a list.
And then a list of strings that is just typed in here directly, okay?
And I'm going to call print_item on numbers and print_item on strings.
And let's see what happens.
Okay, a whole bunch of numbers got printed, all right?
And you should convince yourself that those are the numbers that should have
been printed in that range.
But if I look at the last several, it's 71, 74, 77, 80, they
are increasing by 3 which is the step size in that range, and it does stop at 80.
Okay, which if I added three more would be 83, which is greater than or equal to 82.
So that does make sense.
Notice that when I print the strings, I get Python is fun exclamation point,
each on a separate line, okay?
So again, let's go back up and look at how print_items is working, okay?
For item in alist, let's think about the strings.
First time through, item would get the string Python, all right?
Then we'd execute the body,
which is indented by four spaces after the colon, right?
It says print item, so item's Python, so that gets printed.
Then we go back up to the top again, and item gets the next element of alist,
which is is.
And then we print items, so we print out is and go back to up.
Item gets fun, we print fun, back up.
Item gets the exclamation point, we print it.
Okay, so this is the basics of how we use for loops to iterate over lists.
Now let's take a look at the next function of this file that I've called
print_items_bad, right?
This is also going to iterate over alist and print out all items.
So it's going to do exactly the same thing, but
it's going to do it in a different way.
Instead of iterating directly over the list, we're going to iterate over
a sequence of numbers and use those numbers as indices into the list.
So if we look at the loop here it says for index in range length.
Well, what's length?
If we look above, we call len on alist to get the length of the list.
So range length should be a sequence of numbers from zero up to
the index of the last element in the list.
And this is why range works this way, right?
Why it doesn't include that last number, right?
It's very convenient to use it for things like this.
So I have for index in range length.
This means that index will take on each of the elements of range, starting at zero.
So if we had a linked list of length five,
it would become zero the first time through.
And we'd execute the body, then it would be one, and so on, right?
All the way up to four and then we'd be done.
Now I want you to notice something here,
when I called a range this way I didn't have to convert it into alist.
Range does allow you to iterate directly over the range object that it creates,
without having to first turn it into alist, okay?
Now notice how I print things now.
I can't just print index, that's not what I want.
I have to print alist sub index, okay?
Now why is this bad?
Well, it's not inherently bad but
this is not a good way of iterating over a list, why?
It's very error prone.
What if I screw this up, okay?
What if I had range length plus one,
because I calculated the length in a different way.
I could very easily not iterate over all of the indices of the list.
l could go past in the end, l can miss indices inside, and so on.
So if you're iterating over a list just to do something to issue the items,
you should always use the first form in print items, okay?
There are some times though when it does make sense to use range and
iterate over a sequence of numbers, okay?
But this is not one of them.
It's when you actually need to use the index for something here.
Notice all I'm using the index for is to get the item.
Well, I could have just gotten the item directly.
If I needed the index for something else, like I wanted to know where I was in
the list, then this would make more sense, right?
But let's run it anyway.
Okay, and we can see, hopefully, then it does it exactly the same thing, all right?
We now have the sequence of numbers that got printed out in the same way,
all right?
We just did it in a little bit more dangerous fashion, all right?
So I always would recommend that you use the first way if you can, right?
Iterate directly over the list, if that works, okay?
Only resort to iterating over a range of indices if you are not able
to write the code in the first way that we did inside of print items.
Now let's imagine that we didn't have the len function, and
I wanted to figure out how many elements were inside of a list.
This function count_items here can do so, okay?
So it takes alist as input and then it counts the number of items.
So first I initialize the variable count to be 0.
Then I iterate over all of the items in alist for item in alist.
And I increment count by 1 for each item.
Notice I don't ever even look at item.
That's okay, so I assigned each value of the list to the variable named item.
I completely ignore it, I just increment the count.
And then when I'm done, I return that count.
This is going to be the same as checking the length, right?
So let's try that.
And we run it, and we find out that my list of numbers has 26 items in it,
and my list of strings has 4 items in it, okay?
All right, that's not very interesting, okay?
I didn't actually do anything with each item.
And so here is a more interesting function.
Count_odd_items, now this is not going to work if I
pass it something that isn't numbers, so I now need a numlist.
I want to count the number of odd items in numlist.
So again, I initialize the count to 0 and then I say for num in numlist, right?
That's going to iterate over all the elements of numlist and
assign them to the variable num intern.
And then the body of the loop now, I have a conditional, I say, if num % 2 == 1.
Well, the percent operator is remainder, so I divide by 2 and take the remainder.
If I divide by 2 and take the remainder, if it's 0,
then I know the number was even.
If it's 1, then I know the number was odd.
So I'm checking if it's equal to 1, meaning that the number was odd.
And in the body of the if, I increment the count, count plus equals 1, by 1, right?
So now I'm going to iterate over all the items in the list.
I'm actually going to look at the item and
do something based upon the value of the item.
And I'm going to increment the count for odd numbers and not for even numbers, and
return, okay?
So this is potentially the most interesting loop that we've looked at
here in this lecture, right?
It actually does something with the elements of the list.
And returns me something based upon what was inside the list, okay?
And that tells us there were 13 odd items in the list.
And I strongly encourage you to actually go look at that list.
Make sure there actually were 13 items, make sure you understand it.
Maybe even change it around to count the number of even items in the list.
In this video, we've seen how to use for loops to iterate over lists in Python.
The for in syntax allows us to specify the name of a loop variable and
the list over which we'd like to iterate.
Then the loop body executes for each element of the list.
And within the loop body you can access the current element through the name of
the loop variable that you specified in the for statement.
This is an extremely powerful concept.
Now we only use relatively simple loop bodies in this video of a couple of lines,
but there are no restrictions.
You can write any Python code that you would like inside of the loop body.
You can call their functions, you can print out things, and so on.
This is a useful concept and we're going to see it again and
again throughout the class.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2018 Coursera Inc. Todos los derechos reservados.
