>>PARLANTE: This morning, I talked about
strings, they’re just the most basic stuff, and then we had the string exercises. So the
time for the rest of the day I’m going to talked about lists and tuples, what are their
structures. We’ll have–had a little exercises about that, and then I’ll finish off talking
about dictionaries and files, chart tables, and then we’ll have a large exercise, and
that will complete the day. So that’s in line for today. I’ll probably get you out here
around, I don’t know, 4:15 or some like that. All right. So let’s talk about another Python
type, so let’s fire up the interpreter here. So I did strings. So the next topic I’m going
to show you is the lists. So the lists is in a–appears in square brackets. So if I
wanted a lists of like the numbers one, two, three, that will look like that, like–I mean
I could tie it into a variable to make it very much like my last example. The elements
in a lists, they often are of the same type but there’s no requirement, so I could have
like “1, 2,” and then like “aaaa”,–oops, okay. That’s probably–oh, three commas. I’m
sorry. So, it’ll give a list of a, you know, different types. In reality, mostly, you’ll
have a list of all the same thing for just, you know, just sort the most intuitive case.
Now, Python has this sort of design idea that instead of having, you know, one syntax for
strings and another syntax for list or whatever, Python tries to use the one syntax very consistently
for all things, and so this is a nice quality. It means when you’re learning it, there’s
less to memorize. So, for example, the length function for lists is just the one we learned
before. So, yeah, I could say “lan(a)”, just like for strings. And in fact, many of the
bits of syntax or operations for strings were countless as well. And so Pythons are deliberately
consistent. So, for example, I could do a “+”. So I could say, well, I have the list
“[1, 2, “aaaa”], you know, “+ [3, 4]”. And like with strings, we’ve seen that, right?
It puts them together to make a bigger string. With list, they’re like, put some together
to make a bigger list. So one difference that list have–I’ll set this back to “a=[1,
2, 3]. Is what is–what is the equals to? So if I say “b=a”, “end. The key thing to
remember here is this does not make a copy. What this has done is there’s this one list
sitting in memory somewhere, and it used to be that “a” was pointing to it; and now, “b”
is pointing to that same list. So there’s one list, and they’re both pointing to it.
The way you could tell, all right, we do a little experiment–oh, I’m sorry; I really
didn’t to talk about. How do you refer to the–an element inside of here? Yeah, it’s
just like, just like in the string. So, if I say “a ”, that’s the first element, remember?
So I can check my experiment by using this on the right hand, so I’ll say, well, I’ll
set “a=13”. I’m going to change that first element; lists are mutable, you can
change them. Unlike strings, Strings are the ones that don’t’ change. So if I look at “a”,
it’s now different. But if I look at “b”, it’s different also. So this kind of shows
how they were just pointing to the one thing. If you want to make a cut–mostly, you’re
just having the one list or whatever it is, and having pointers sort of sprinkle through
your [INDISTINCT] all pointing, all sort of–I could say, sharing that data structure. For
most part, that’s just totally fine. You shouldn’t–[INDISTINCT] block that out. I will show you how to make
a copy, just if you wanted to. The way you make a copy–or actually, I’ll set “b” to
be a copy of “a”–is of you–the Pythonic way is use slice syntax. So if you say, “[:]”
that’s the kind of Pythonic way of saying, “Well, here’s a linear quantitative things.
Please make a copy of it.” So, now “b” relays a copy if I change “a” and “b” would change.
Yeah? Question over here?>>So the question was, if you’ll be framing
a copy for me to change “b” and also change anything…?
>>PARLANTE: Yeah. So the question is question is, so before I made I copy, if I change “b”
or if it’s “a”? Yes. So there’s this one list in memory, they’re both pointing to it. They’re
literally sharing it. Now, I’m going to say, “Look, as a practical matter for your Python
programs, there’s just not a problem. It’s just fine.” In C++ or in C, you would want
to make copies mainly because of the memory management, like trying to know when to free,
you know, when to reclaim the memory. But Python, like, you know, any reason about language
has a garbage collector. It just takes care of the memory collection, and so as a result,
this need to make copies, just kind of goes where–when I found transitioning from CC++
language is, to Python I found that it was making a lot of your copies, likes the need
do that had just gone away. So I guess what I’m saying is like, you may have an instinct
to make copies, where I’d say, attempt to keep in check, the key you’ll find, it just
not make copies and most stuffs just going to work fine. All right. So let’s see we got
the square brackets, the length, the–let’s see, what are “a” and “b” this days? Oh, they’re
the same. The “==” does comparisons just like string. So you have two lists. It actually
follows the list and checks piece by piece, which are the same. So as before, it does
have a kind of an intuitive notion of checking. Now, what’s the other thing we did lists,
right, or I’m with strings [INDISTINCT] was slices. That works with list as well. So right
here, I’ve got these lists. If I say “a”, you know, I don’t know what, [1:3] or whatever,
I can pull a slice out of the list. So for–maybe the most common case is, like, if I want to
talk about a list, except or without the right installment. So, I’ll wait until we get to
the exercises, but, yeah, you’ve got this very concise syntax for kind of talky about
some parts of a list. All right. So let me show you the main syntax for this thing. So
a very common thing to do–actually, I’m going to–I’ll write it over here and I’ll I speak
louder, a very common thing to do is to loop over a list. And so, in–for example in C,
or right, you’ve maybe written that loop where you say, you know, “for i=0, i
>>PARLANTE: Well, so let’s do it, so the question is how does it know that num is also
those numbers? What its doing is num is just a variable name just chosen by me, it could
have been anything, and what it does in the loop, essentially, what it’s doing inside
the loop is like num is equal to whatever, you know, kind of like, what the next value
is. It assigns it into num, just like a variable, and then after that, then it runs with a little
bit of code I have, and then it loops around and does the next one. So in other languages,
it might–it’s similar to the idea of an iterator. So, this is for–the exercises of this will
come up late. The idea that you have a list of a bunch of things and you kind of want
to do something for each one, that is–that’s a common case and this is certainly the syntax
you should use for that. There is a related syntax–this is like this is the first one.
The second one is very simple which is just–you have some value, and you want to, you want
to check if it is in a list, and you can imagine–I’m sorry, is this too low down? You guys can’t
see? Sorry. I’ll write it up above. I’ll put up here. Let’s stuck this here, all right.
If you want to check if a value is in a list, you can write this way. You just put whatever
the value is and then the word “in”; just the “in” by itself, and then whatever the
list is. So it’s very short. So, if you’ve got a–I mean, this works for list. It actually
works for a lot of things, just “in” in Python. There’s this built-in way that you’ve got
some composite data structure, and you want to tell, is this thing in here? So what’s
“a”? So, for example, I can just write “2 in a”, and that’s just going to go over “a”
figure out somehow, or with what something, like, let’s say the “14 in a”. There’s the
“False”. So there’s another one–this sort of higher in the food chain things, you might
have an instinct, “Oh, I want to see if it’s in here. Oh, I’m going to write a four loop,
and I guess I’ll loop through, and I’ll compare each one with equals, equals rarely.” I’d
be like, “no”. In Python, you’ve–it’s just built-in. You’ll say, “Look, is this in there?”
It works for actually a lot of data structures, and in–the [INDISTINCT] case it’s actually
quite efficient, you know. It does–it does something smart depending on what data structure
you have. So you should not worry about doing something with them. So, along with slices,
you should just–so I’d rather that you just go ahead and memorize those. Those two syntactic
constructs are very common, you should just know those. And, of course, my examples later
on, so up here all sorts of time. All right. So let me show you just as with the string,
we had methods like “.lower” and “.replace” and “.find”, whatever. The list is the same
way. It’s got all sorts of built-in stuff. I’m just going to show you a couple. One is
there’s an append–and you can just guess what that does. Just to–puts it on the end
there. One important thing about append is that it does not return a new list. It returns
the special value of none which I, you know, you saw in the [INDISTINCT] a little bit.
None upper case N–I’ll just type here–is sort of the null value. It means like nothing.
So, “a.append”, it returns nothing. What it does is it modifies the list. So, it does
not–it would be wrong to write this, “a =a.append(xx)”, you know, say, well, I have
to say no. I mean there is this follow the world where–I mean some other language maybe
that were, but in Python that just happens to not work at all. And it’s because append
does not return anything. It modifies the list in place, and that’s–I’ve absolutely
made that here myself. It’s just the–there’s this two different paradigms they could have
chose, and they chose the one right at that one. All right. Also, there’s a–it’s kind
of the reverse of append, there’s pop. And so if I–this is by position. So if I say,
“pop(0)”, what that’s going to do is it pop–it removes, it sure pops up the zero with element,
and returns it to me, and it modifies list. So, it kind of removes it from the list and
send it to you. So, you want to kind of remove an element and just kind of get it out of
there. Then, pop–pop [INDISTINCT]. And were–and, then you should look at the docs. Yes, there
are dozens of built-in list methods for all sorts of common stuff. And if you have a problem
involving manipulating a list, searching it or replacing or whatever, yeah, you should
go look it and go find the built-in ones. There is a particular case though that I want
to show you and that is–well, actually–I’m sorry. There is–there’s one–another one
that I’m going to show you, which is something I haven’t talk about so far. So here is A,
there’s a–I guess this is an operator called del, I mean, delete. And what delete does,
obviously, it deletes. But, particularly, you can use it on a variable. So if I say
del A, what that does is it kind of removed the definition of A from my local scope. Whereas,
when I design A to six or whatever that I put in there. So, now, if–after that if I
try and use A, it’s like, “Oh, that’s not define.” So it’s kind of the reverse of the
direction I’ve tried before. And what happens, the del also works on list. So if I say A
is equal to one, two, three, and let’s say if I can say, well, you know–if I can say
“A”, that’s the two, right. So in terms on how you can use a del to actually retain
the list, so if I say del of “A”, that kind of deletes out on that list, but now,
the list actually shrinks. So that’s–I’ve shown you how to add, I’ve shown you how to
pop, also del has another way. You can surf the one there. Yes, question over here.
>>So if you do–if you design A to B for instance without copying it but actually point…
>>PARLANTE: And so this one–in these cases, we’re actually just doing the interpreter.
Okay, let’s say B is something like it’s 12, and I say A equals B.
>>And then you del A?>>PARLANTE: Okay. And so if I say del A…
>>B is still B.>>PARLANTE: …then B is still fine.
>>Okay.>>PARLANTE: All right. The del A–what it
does, it’s just kind of removes–I mean, it’s sort like when I had A and B point at the
list, right. It’s like, well, the list is still there. Deleting A, I’m just like–I’m
deleting the idea of A, but whatever it pointed to, something else might have been pointing
to as well. Now, with the 12–I use the word point there as a little inaccurate but the
basic pattern holds. All right, so the most interesting thing with list I want to show
you is sorting. So there’s this old way of doing sorting. Well, there’s actually a dot
sort method on the list and I want you to not use that one. I’m going to show you this
newer, cooler way that it’s just better than everyone. And you can–yeah, with all those
dinosaurs were using dot sort you can just like look down on them. All right, so what
I’m going to do–well, first of all I’m going to show you the most basic case. So let’s
say A equal to you know, four, two, one, six. So the simplest way to do sorting is there’s
a function called sorted. And you can feed a list into sorted, and what it does is it
makes a new list and it sorts it, sorts it in increasing order. Now, so in this case
when I call sorted on A, it’s making this new list and then it sort again. In this case,
we’re getting a numeric sort. In reality what’s going on is it’s the comparison in Python
depends on the type of thing being compared. And in this case, it’s a list of int. And
so when I gets down to the comparing one int to another it sees like, “Oh, this is two
ints, so I should do a numeric comparison. If, instead, I have the list of strings, it
would have gotten down to comparison with the scene, “Oh, I have two strings,” and so
it would have done a textual comparison. Again, it has that sort of Python quality like at
the last possible second it sees whatever the two types are and it does something appropriate,
I guess. So one of the things about sorted–and, actually, I’ll pull up the help page for sorted.
Remember help? So if I say “help(sorted)”, it’s pretty [INDISTINCT], “sorted(iterable)”.
So this actually works for a list. You can actually feed into sorted any–an iterator–some
other things that kind of–are capable of producing list so that they are not themselves
list, you can feed those into sorted too, it just works with all of this, anything that
kind of looks like a sequence. So these syntax here were first two optional named arguments.
And so this built-in, like–yeah, you can just not specify CMP or key or reverse, but
if you do specify them, then, you can sort give these extra arguments. This is a nice
quality in Python. So in this case, I had “sorted(a)”. In that way, I could also say,
“sorted(a,…” and then one of the optional argument is called reverse. So, I mean, I
have to go look up and see if that was the name, but I see the name was reverse. And
if I pass through for that, then, it still sorts them but I just get it the backwards
way. So that’s a very common problem. I see you just want to sort the other way so, and
so that’s the built-in. Yes, question.>>I just need to ask to see whether A gets
assign a sorted list or gets [INDISTINCT].>>PARLANTE: Yeah, sorted makes a copy. It
makes a new one and sorts that.>>[INDISTINCT] into a new…
>>PARLANTE: Yeah. Yeah. So for example–well, so here is A, it’s unchanged right?
>>Yeah.>>PARLANTE: And here’s “sorted(a)”. What
I could do–this is what you’re suggesting–is I could say A is equal to “sorted(a)”. Like
yeah, I don’t care to keep the original on that, that’s fine. So now, it’s sorted. So
you have the–once we spend over it you would even don’t have a choice right, so this way
you get to pick. All right. So let me show you just like basic sorting. So, now, I want
to show you this little more sophisticated about how to do custom sorting in Python.
And the Python syntax–the Python structure for this, I think, is really nice, but it’s
going to be a little more complicated. All right, so I’m going–and I’m going to set
up my case, so it’s exactly the same as the one in the handout. All right, so here, I’m
going to have some strings. So if I say “sorted(a)” here, the strings what–by default what I
get is textual sort. Now, the problem I want to consider is–for custom sorting, right,
you want to sort some other way, not just textually. The case I want to consider is,
well, suppose I want to sort this by length, right. I want to D first and then the B’s
and then C’s, right. I want kind of increase in order by length just for–just as an example.
How might I do that? Well the old way to specify custom sorting in a lot of languages is that
you write what’s called the two argument competitor. You provide some function that takes two arguments
and compares those two and returns either a negative number or zero or positive number
depending on how you wish for those to be ordered and you feed that into the sorting
function and then uses it. That is a classic technique, the two argument comparative technique.
But it’s a little messy, it’s a little difficult to describe, and it’s just not that great.
So Python, we’re not just going to do that way. I’m going to show you a different way.
And the idea is I’m going–here’s a piece of art in the handout. So in this case at
the top, I’ve got my original list. And I’ve got this idea that what I want to do is I
want to sort by the length. So the way it’s going to work in Python is I’m going–you–we
are going to provide a function of one argument. This called the key function. And this function
of one argument, then, what the system is going to do is it’s going to run it over our
original list. And for each element in the original list, it’s going to call the function
of one argument and it’s going to get a single value and it’s going to build up a list of
those new values. So I’m going to kind of walk over here kind of point at my drawing.
So here at the top, we’ve got my original list. Now, imagine the function of one argument
that I’m going to use in this case is the Len function. We’ve been using it all along,
right. And Len, when you call it on a string, it returns the length to that string. So I’m
going to give it–I’ll show you the syntax, but I’m going to say, “Hey, use Len as the
kind of key function in this case.” So it’s going to call Len–what is it–five times,
and it’s going to get this numbers right. Three for the string length–three for the
string length, just gets this kind of shadow list of new values. So–now, here’s where
the magic happens. What the sorting is going to do when I call sorted, I specify key function,
it’s going to make the shadow list and then it’s going to sort the shadow list. So the
one is going to come first, right, and then the two, whatever, it figures that out. And
I got to make this hand waved motion that’s why it’s kind like sorting motion, but then
it applies it to the original list. It actually shifts around the original elements. And so
the result is that I get to the bottom. I get the original elements but sorted according
to the values of the shadow list. Now, it’s a little hard–yeah, it’s a bit much to follow,
but I’ll tell you, in my experience this is a much more convenient way to do custom sorting.
You just set–sort of gets your brain around this idea projecting out the shadow list.
So before I take questions, let me just demo that working. Show you what that looks like
and then we can–then, we can work on some of the examples. Right, so there’s A, and
here’s Len, it’s like a function. It’s a lot like a function. So what I’m going to say
is what I want is “sorted(a)”, and I’m going to give this optional argument called “key=…”
and I’m going to specify a function to use, in this case I’m just going to say, “Yes,
use Len.” So if I do that, then, it’s under the hood. It’s kind of projecting out that
list. Now, let me do a second example, and I’m going to change my list a little bit.
Let’s changed–let’s changed “a=’aaaz”. I’m going to mix my problem up a little bit
here. Let’s say, “How do I”–I want to sort this by the last character in each string.
I want to ignore all the other characters. Just give me–this is the sort of problem,
there’s a custom sort that you might solve with the key equals function. And I’m going
to do it with a def just like what you’ve done. So I’m going to say “def Last(s)”, and
we’re going to do this on one line. There’s nothing–because I’m the interpreter here.
So let’s say, def Last(s): return s[-1]”. Okay. Now, last is fine. So, now, if I say,
“Last” just like so, like, “Oh,” that points to a function just like if I say Len, okay,
yeah, that’s function. The one that’s built-in, the one’s I just made, but it’s still going
to work. All right, so the last function, you give it a string and it just return that
last character. So, now, if I say sorted so, now, I remind what is that? So now, if I say
“sorted(a, key=…” just the thing I just defined, “Last”, then check it out. So, now,
I’ve done custom sorting. And in this case, what it’s doing in the shadow list is it just
pulling out whatever the last, you know, the minus one–whatever the last character is
sorting by that. So there’s a couple example of custom sorting. Yes, question.
>>So if the last time when A was DD, would it release by factors DD, would it [INDISTINCT]
like do the first sort by number of characters and then within if there were two?
>>PARLANTE: Actually, yeah. So I’m going to answer a slightly different question. So–I
mean there’s this idea of, “What if I want to sort by one thing and then I want to sort
by something else?” You know, let me–I can answer that more effectively when I’ve covered
one more data structure. There is a way of doing that, but I’d like to just hold off
on it. I mean, it’s a very reasonable question.>>[INDISTINCT] what, would it just be random
if you didn’t use that extra [INDISTINCT].>>PARLANTE: I don’t think it would works.
Do you want? But what I preferred to, I’m going to save time and show you the way that
it does work, then, we can talk about it, okay. And so that’s why unsatisfying, but
there’s these other data structure we’d really need for this. All right, so I understand–I
think the sorted thing is one of the more difficult things, kind of kick your head around.
But, yeah, predictably, the exercises have like a bunch of custom sorts and it’s a very
powerful technique. So I’d say hold off on that. And then I do have this beautiful art
in the handout so try and–try and follow. So just hold on with that, on the next set
of exercises which will be pretty soon, you’ll get a chance to play with that. All right,
so let me show you, just a couple other things with the list. So one–I’ll stick with A,
just these strings. One fairly common thing to do once you’ve got your program and you
want to now produce your output is you want to–you want to make a string out of list.
So, like, one thing you might do is maybe loop through this list, right? I could type
“for s in a:” and, you know, kind of print each element or something. It turns out, that’s
okay but there’s a built in that just takes the list and sort of concatenates or whatever
all the parts of it together just in one step. So that’s such common on our version; that’s
nice to know. So, for example, if I were to say, so this is called dot join. So if I were
to say ‘:’.join(a), what it does is it just puts it all together in one string just in
one step. And so it’s a little unintuitive but actually the case I most use–use most
often is backslash n; like I say new line, dot join, and then really I’ve now got one
per line but just all in one step. And then I can just print that in one step or, you
know, write it to a file or whatever. So that is a handy one to know. I’ll switch back to
the colon 1. So going in the other direction, there’s also a split. So actually here, I’ll
say b is equal to that so now b is the string I’ll put together. If I say, ‘:’.split(b)–oops,
was that wrong? Oh, I’m sorry, no, it’s the other way. Sorry, b.split(‘:’) so you have
a string, you called dot split and you say here is essentially the delimiter. Then it
kind of explodes it out so you can recover the original list. So split out either–you
know these are really not actually deep but this just happens to be a common case. So
those are handy to know. Oh, I should mention, those are not regular expressions; those are
just substrings. We’ll do regular expressions tomorrow. Yes, question?
>>Can you talk about something really simple which is like, what if you were going through
a list of data and you’re making a list. Maybe here you are just defining this but
>>PARLANTE: Yes, yes. Yes, here, so let’s do a little example like that, yes. So the
question is how do you kind of make a list, yes. So one pattern that shows up in the exercises
is like let’s say I’ve got “a” here and I want to loop through this and I want to–I
want to pick out some of them and put them on some other list. A pattern might be like
this where I’ll say a result is equal to the empty list and then I’ll say something like
for s in a: and I going to kind of–I want to add some of them to the results or whatever.
The way you would do that, I’ll just add them all in this case but I’m going to loop through
it. I want to put some of this. I would just use append so I’d say result.append(s) in
this case. So now if I look at results, I mean, essentially what I’ve done is I’ve just
copied all this over. So in terms of–that is a common pattern. You start with empty
list and you kind of put some stuff in it.>>I guess, like let’s say you’re our data
or whatever, you don’t have any list and your’e starting your for loop…
>>PARLANTE: Yes, yes. So the question is, yes, what if you have documents, I mean, what
you are getting at is realistic. The trick is I’m going to show you how to open files
and read text out of it and then I think at that moment I’ll answer that question. But,
yes, thus far, I’m just doing list a little bit. You know, I haven’t gotten to that yet.
All righty, so the last thing I’ll show you is just for completeness; I haven’t showed
you like a traditional for loop like i equal zero one to the–you know, like in C or java
script, you might do that all the time. Mostly, the ones I’ve shown you, these techniques
just cover it. However, there–I will show you how–if you want to count a bunch of numbers,
the way to do that is there is a function called range. And what range does is it sort
of on–if I say range 20 it’s sort of on the fly appears to build this list, starting at
zero and running up to but not including that number. So, if you want to count from, you
know, zero to nineteen, you could say for i in and then call range to kind of on the
fly make this list appear, and so that would be a way. Now, there is a little bit of difference
between Python 2, 4 and Python 3, whether that list is really created in memory or is
it fake-created. The more modern version is just fake-created or you know which saves
memory. So you can–you should not worry about that efficiency detail because the more modern
versions are just all over it. Now, I have shown you just the most simple case of calling
range where you give it one argument but in fact you can specify the starting number and
the end number and should it go by fives, all those kinds of permutations range supports
when you give it more optional arguments. And so if you want to generate a series of
numbers, that would be the way to do it. There is also a while loop which now I’m just going
to demonstrate but yes, it works like while loops in other languages. The most common
case though is the one I’ve showed you, just the for loop to loop over our question. Last
thing I’ll have to say about the for loop is that it does have this constraint which
is when you are looping over a list, you cannot modify that list in a way which changes its
length or structure. So you can’t add an element–it kind of makes sense, if you add an element
in the loop, you could kind of get this weird infinite structure. So do not modify while
iterating over. Incidentally, Java has that same constraint, sort of, based on–there
is an implementation reality underneath there. All righty, so we are almost ready for another
exercise. The last thing I want to show you is the tuple. So, I showed you strings surrounded
by quotes, lists surrounded by curly braces. The tuple is actually–it’s a modest little
data structure and it looks like this. Tuple is put in parenthesis and has commas inside
to separate the elements. So a tuple–now a list can grow and shrink, right? It can
start as length zero and I can append, put stuff in there, delete, whatever. The tuple
is fixed-sized. You create it length three, it’s length three forever. In fact, it’s immutable.
You just can’t change it. So what–the tuple is good if you have some fixed number of items.
Like let’s say you want to store an x, y, z coordinate in three dimensional space, right,
there’s never going to be a fourth number. You know it’s just these three, I want to
lock them together. Tuples are good for that. Or let’s say you have a URL and a score and
it’s these two things so, like, I want these two things to go together. In Python, you
can put those on a tuple length 2 and store that on a list or return it from a function
or whatever. So the tuple is the kind of anonymous way of taking a fixed number of things and
just kind of locking them together so you can pass them around or store them or whatever.
So the–and in the later exercises, you’ll see some examples of this. So I’ll sign a
to this tuple I guess. And then kind of like you could guess, I’ll make this claim that
Python is all consistent. So how do suppose you tell the length of a tuple? Of course,
it’s len, right? And how do you pick an element out? Yes, it’s square bracket. So all that
stuff list, strings, you know, pretty much works for tuples as well. The one difference
is the tuple is immutable. So if I say a square bracket zero equals 13, I try to sign into
it, that’s going to fail, right? So the tuple can’t be changed. Once you create it, it’s
like a string. So tuples and strings, immutable; lists, mutable. There was a question earlier
about sorting. And it turns out, if you want to sort by one thing and then sort by another
thing, the best way to do that is with tuples. And so I think I can do a short example here
so I’ll say 1, comma, a, comma, so this is–I’m making a list of tuples here. Oops, okay,
let’s make that b and then here we’ll make this 2, comma, a. So, the way it’s going to
work is if you sort tuples, just the natural under-the-hood sorting, what it does is it
first compares the first elements of the tuples. And if they’re different, it just sorts by
that. But if those elements are the same then it goes to the next one. So here, and I need
to make this–and I would just say 1a. All right, so what I’ve made is a list of tuples.
And to show this off, I think if I do sorted on that, where the first number are the same,
it goes to the second, right. So in the two 1 cases, then it is sorted by a b and then
this one is last. So that is a little bit of a detail. It’s not something–I haven’t
planned on mentioning this but for the question back here, if you want to sort on one thing
and then sort by something else, what you can do is write your key function to return
a tuple. And then in–by whatever you put in that tuple, you can get the behavior you
want, you know, put the thing you want to sort on first, that’s the first thing, and
then a comma and whatever the second thing is and it will just go automatically go to
the second thing if the first thing is the same. And that is just built-in Python sorting,
like it gets how to sort tuples that way. All righty, so one other thing I have to show
you with tuples, this is kind of, dare I say, kind of a Perl, I think it is sort of a Perl
feature is that if you say (x, y), there’s a special thing with assignment and variables,
if you say (x, y) in tuple equals (1, 2), what it does is kind of a parallel assignment.
So now, x, x is 1 and y is 2, not super common thing to use but it does show up now and then.
The–okay, now, there’s more stuff though I’ll show you later about that. All righty,
so what we’ve seen really at this point, so let’s take in, is list, how to loop over them
and dot append or whatever and sorting and a little bit about tuples. So what I would
like you to do is take a look at the exercise. I’m sorry, question?
>>Yes, does slicing work with tuples?>>PARLANTE: Yes, slicing works with tuples.
So what I would like you to do is take a look at the exercise list 1 dot P Y. This is going
to involve doing basic stuff with lists and also a little bit of custom sorting. As before,
if you are just so unbelievably fast that you finish those then there’s a list dot 2
dot P Y. But mostly, I’m just hoping people can, you know, get at least some of the problems
done in list 1 dot P Y. And what I’d like you to do is work on that, say, for half an
hour. So I’m going to pull you guys back here at 2:20. I’ll do one more lecture and then
we’ll have significantly bigger exercise till I finish out the afternoon. Okay, so, off