Python for Informatics - Chapter 9 - Dictionaries

This is Chapter 9 - Dictionaries from Python for Informatics - Exploring Information. www.pythonlearn.com
All Lectures: http://www.youtube.com/playlist?list=PLlRFEj9H3Oj4JXIwMwN1_s­s1Tk8wZShEJ

Hello again, and welcome to Chapter Nine
of Python, Dictionaries.

As always, this lecture is copyright
Creative Commons Attribution.

That means the audio, the video, the
slides, and even my scribbles.

You can use them any way you like, as long
as you attribute them.

Okay, so this is the second chapter

where we're talking about collections, and
the collections

are like a piece of luggage in that you
can put multiple things in them.

Variables that we've talked about sort of
starting in

Chapter Two and Chapter Three were simple
variables, scalar.

They're just kind of one thing, and as
soon as you,

like, put another thing in there, it
overwrites the first thing.

And so if you look at the code, you know,
x = 2 and x = 4,

the question is, you know, where did
the 2 go?

Right? The 2 was there, x was there,

there was a 2 in there, and then we cross
it out and put 4 in there.

This is sort of the basic operation, the
assignment statement, it's a replacement.

But a dictionary allows us to put more
than one thing.

Not using this syntax, but it allows us to

have a variable that's really an aggregate
of many values.

And the difference between a list and a
dictionary

is how the values are structured within
that single variable.

The list is a linear collection,

indexed by integers 0, 1, 2, 3.

If there's five of them, it's 0 through 4,
very much like a

Pringle's can here, where they're just
stacked nicely on top of each other.

Everything's kind of organized. We talked
about it in the last, in the last lecture.

This lecture we're talking about dictionaries.

A dictionary's very powerful.

It's, and its power comes from a different
way of organizing itself internally.

It's a bag of values,

like a just sort of, just stuff's
in it, it's not in any order.

Big stuff, little stuff.

Things have labels.

You can also think of it like a purse with

just things in it that's like, it's not
like stacked.

It's just, stuff moves around as you're going

and that's, that's a very good model for
dictionaries.

And so dictionaries

have to have a label because the stuff is
not in order.

There's no such thing as the third thing.

There is the thing with the label perfume.

There's the thing with the label candy.

There's the thing with the label money.

And so there's the value, the thing, the money.

And then there's always also the label.

We also call these key/value.

The key is the label and the value is
whatever.

And so these pink things are all labels for

various things you could put in your purse.

So you could say to your purse, "hey purse,
give me my tissues."

"Hey purse, give me my money."

And it, it's in there somewhere and the
purse sort of

gives you back the tissues or the money.

And it's, Python's most powerful data
collection is the dictionaries.

And it's when

you get used to wielding them you'll say,
like,

whoa, I can do so much with these things.

And at the beginning you just sort of

learning sort of how to use them without
hurting yourself.

But they're very powerful.

It's like a database.

It's, it allows you to store very arbitrary
data organized in however you feel like

organizing it, in a way that advances the
cause of the program that you're writing.

And we're still kind of at the very
beginning, but as you learn more,

these will become a very powerful
tool for you.

They, dictionaries have different names in
different languages.

PERL or PHP would call them associative
arrays.

Java would call them a PropertyMap or a
HashMap.

And C# might call them a property bag or
an attribute bag.

And so they're, they're just the same
concept.

It's keys and values is the concept that's
across all these languages.

Just are very powerful.

And if you look at the Wikipedia entry

that I have here

you can see that it's just, it's a concept

that we give different names in different
languages. Same concept, different names.

So like I said, the difference between a
list and a dictionary, they both can store

multiple values. The question is how we
label them,

how we store them, and how we retrieve
them.

So here's an example use of a dictionary.
I'm going to make a thing called purse.

And I'm going to store in purse, this is
an assignment statement,

purse sub money.
So this isn't like sub zero.

This is sub money.

So I'm actually using a string as the
place.

And, so I'm going to say stick 12
in my purse

and stick a Post-it note that says
that's my money.

Candy is 3. Tissues is 75.

And if I look at that, it's not just the
numbers 12, 3, and 75 as it

would be in a list. It is the connection
between money and 12,

tissues is 75, candy is 3.
And in the key/value, that's the

key and that's the value.
So candy is the key and 3 is the value.

Now I can look things up by their name,
print purse sub candy.

Well it goes and finds it, asking hey purse,
give me back candy, and it

goes and finds the value, which is 3, and
so out comes a 3.

We can also put it

on the right-hand side of an
assignment statement,

so purse sub candy says give me
the old version of candy,

and then add 2 to it, which

gives me 5, and then store it back
in that purse

under the label candy.

So we see candy changing to 5.

And so, this is a place, and you could

do this with a list except these would be
numbers.

You could say purse sub two is equal to
purse sub two plus two, or whatever.

But in dictionaries, there are labels.

Now, they're not strings.

Strings is a very common label in
dictionaries, but

it's not always strings, you can use other
things.

In this chapter we'll pretty much focus on
strings.

You can even use numbers and then you
would get a little confused.

But you can.

So here's sort of a picture of how this
works.

So, if we take a look at this line purse
sub money equals 12,

it's like we were putting a key/value
connection, money is the label for 12.

And then we sort of move that in.

And it's up to the purse to decide
where things live.

If we look at the next line, we're going to
put the value in with a

3 in with the label candy, and we're
going to put

the value 75 in with the label of tissues.

And when we say hey purse, print yourself
out, it just

goes and pulls these things back out and
hands them to us.

And what it's really, it's giving us both the
label and the value and it's necessary

to do that cause they're just like 12,

75, and 3. What exactly is that?

And so this syntax with the curly braces

is what happens when you print a
dictionary out.

The same thing happens when we're sort of
printing purse sub candy, right?

Purse sub candy,

it's like dear purse, go and find the candy
thing.

Look at that one, look at that one.

Oh, yep, yep, this is candy.

But what we're looking for is the value,

and so that's why 3 is coming out here.

So go look up under candy, and tell me
what's stored under candy.

These can be actually more complex things,

I'm just keeping it simple for this
lecture.

And then, when we say purse sub candy
equals purse sub candy plus 2, well it

pulls the 3 out, looking at the label
candy, then adds 3 plus 2 and makes 5,

and then it assigns it back in, and then
that says, oh, go, go place this number 5

in the purse with the label of candy,
which then replaces the 3 with a 5.

Okay?

And if we print it out, we see that the

new variable, or the new candy entry,
is now 5.

Okay?

So if we just sort of put these things
side by side, we create

them sort of both the same way and we make
an empty list, and an empty

dictionary, we call the append method
because

we're sort of just putting these things in

order. You gotta put the first one in
first. So it's not telling you where.

You kind of know that this

will be the first one, cause we're
starting with an empty one,

and this will be the second one.

We put in the values 21 and 183, and then
we print it out, and it's like okay, you gave

me the values 21 and 183, I will maintain
the order for you,

there's no keys other than their position.

The position is the key, as it were, so if
I want to to change the first one to 23,

well, I say list sub zero, which is this,
and then change that to 23.

So this is sort of used as a lookup to

find something. It can be used on either the
right-hand side or the

left-hand side of an assignment statement.

Comparing that to dictionaries, I want to
put a 21 in there

and I want to put it with the label age.

I'm going to put 182, put that in with the
label course.

So we don't have to like, make an entry.

The fact that the entry doesn't exist,

it creates the age entry and sticks 21 into it,

creates the course entry, sticks 182 into it.

We print it out and it says, oh, course
is 182 and age is 21.

This emphasizes that order is not
preserved in dictionaries.

I won't go into like great detail as to
why that is.

It turns out that that's a compromise that

makes them fast using a technique called
hashing.

It's how it actually works internally,
go Wikipedia hashing and

take a look.

But, the thing that matters to us as
programmers primarily

is that lists maintain order and
dictionaries do not maintain order.

They, dictionaries give us power
that we don't have in lists.

I mean they're very complimentary.

Now there's not this one that's better
than the other.

They've very complimentary.

Different kinds of data is either better
represented as a list

or as a dictionary, depending on the

problem you're trying to solve.

And in a moment we'll, we'll be writing
programs that are using both.

So if we come down here and I say,

okay, stick 23 into, assignment statement,
into ddd sub age,

well that will change this 21 to 23,
so when we print it out.

So you can, this part, where you look
something up and

change the value, you can do either way.

It's just how you do it here

is a little bit different, okay?

So let's look through this code again.

And so I like, I like to use the word key
and value.

Key is the way we look the thing up,
and in lists

keys are numbers starting at
zero and with no gaps.

In dictionaries keys are whatever we want
them to be,

in this case I'm using strings.

And then the value is the number we're
storing in it.

So we create this kind of a list with that
kind, those

kinds of statements.

This statement creates this kind of a thing.

Now, if we, if we think of this assignment
statement as moving data

into a new, into a place, a new item of
data into a place.

It's looking at this thing right here.

Right? It's like, that's where I want to
move it.

And so it hunts, and says, look the key up.

And that's the one that I'm going to change.

And then once it knows which it's going to
change,

then it's going to take the 23, and it's
going to put the 23 into that location.

And so that's how this changes from that
to that.

Similarly when we get down to here, we're
going to stick 23 somewhere and

this is, this expression, this lookup
expression, the index

expression ddd sub age, is where we're
going to put it.

So, we're looking here, where is that thing?

Well, that thing is this entry

in the dictionary. And so now when we're
going to store the 23,

we know where the 23 is going to go.

It's going to overwrite the 21 and so the
21 is

going to change to 23, okay? So they're
kind of similar.

There are things that work similar in them

and then there are things that work
differently in them.

We can make literals, constants, with

curly braces. And they look just like the print.

That's one nice thing about Python.

When you print something out it's showing
you how you can make a literal, and

basically you just open with a curly brace
and say chuck colon 1, fred 42, jan 100.

And we're making connections.

key/value pair, key/value pair.
We print it out and

No order. They don't maintain order.

Now they might come out in the same order,
but that's just lucky.

Right?

All the ones I've shown you so far don't

come out in the same order, which is good
to demonstrate it.

If it one time came out in the same order
that wouldn't be broken.

It's not like it doesn't want to come out
in the same order.

It's just, you don't, it's not internally
stored, and you

add an element and it may reorder them.

You can do an empty dictionary with just a
curly brace, curly brace.

So, I'm going give you another example.

And I'm going to show you a series of
names.

And I want you to figure out what the most
common name is

and how many times each name appears.

Now these are real people.
They actually work on the Sakai project.

Steven, Zhen, and Chen, and me.
So these are people that are actually

in the data that we use in this course.

Okay? And so I think I'll show you about
fifteen names

and you're to come up with a way, I'm
going to

show them to you one at a time, you need to
come up with a way to keep track of these.

Okay?

So I'll just, with no further ado I will show
you the names.

[BLANK_AUDIO]

Okay, so that's all the names.
Did you get it?

You might have to go back and do it again.

How did you solve the problem?

What kind of a data structure did you
build to solve the problem?

Or did you just say wow that's painful, I

think I will learn Python instead, in
solving that problem.

Okay?

So pause the, pause the video if you want and

write down or go back, write down what you
think the

number of the most common name is and how
many times.

Okay. Now I'll show you.

So here is the whole list.
It's all of them.

And now that we see all of them, we
use our amazing human

mind and we scan around, and look at
purpleness and, and all that stuff.

And then we go like, oh, this is a so

much easier problem when I'm looking
at the whole thing.

And I think that the most common person is
Zhen, and

I think we see Zhen, I think we see Zhen
five times.

And I think csev is one, two, three and
Chen Wen is one, two.

And Steve Marquard is one, two, three.

So the question is, what is an effective
data structure if you going to see

a million of these, what kind of data
structure would you have to produce?

Because you can't keep it in you head

even, even this number of people, you can't

even this amount of data, no way you can
keep it in your head. You have to come

up with some kind of a variable, as it were,

just like largest so far was the variable.

Some kind of variable that gets you to

the point where you understand what's
going on.

And so this is the most common technique
to solve this

problem where you keep a running total of
each of the names.

And if you see a new name, you add them to
the list.

So csev and then you give him a one,

and then you see Zhen and you give her a
one,

and then you see Chen and you give her a
one.

And then you see csev again and you give
him a two.

And you see a two, and a two, and a one
right?

[COUGH]

And so then when you're all done you have
the mapping, right, of these things

and you go oh, okay, let me look through
here and find the largest one.

That's the largest one and so that must be
the person who is the most.

So you need a scratch area,

a data structure or a piece of paper as
it were,

and so that's what, exactly what
dictionaries are really good at.

You could think of this as like a
histogram. You know, it's,

it's a bunch of counters, but counters
that are indexed by a string.

So we use a lot of this.

And so this is a pattern of many counters
with a dictionary, simultaneous counters.

We're counting a bunch of, we're looking

at a series of things, and we're going to
simultaneously keep track

of a large number of counters, rather than
just one counter.

How many names did you see total? Whatever,
12. But how many of each name

did you see is a bunch of counters, so
it's a bunch of simultaneous counters.

So a dictionary is, is great for this,
a dictionary is great for this.

We, when we see somebody for the first

time, we can add an entry to the
dictionary,

which is kind of like going oh,
csev one,

and then Chen Wen one. Now these don't
exist yet.

Right? So we've got csev one and Chen
Wen one, so

that creates an entry and sticks a one in
it and the

mapping between the key csev and the value
one, the key Chen Wen

and the value one and then we say, hey
what's in there?

Oh, we've got a csev is one and
Chen Wen is one.

And then we see Chen Wen a second time,

so we'd add another number right there.

So this old number is one, we add one to
it and we get

two and then we stick that back in and
then we do the calculations.

We do a dump and say oh there's two in
Chen Wen and one in csev.

Okay?

So this is a great data structure for the
simutaneous counters like what's

the most common word, who had the most
commits, da, da, da, da, da.

Now, everything we do we have to figure
out

like, when you're going to get in trouble
with Python.

When Python's going to give you the old
thumbs down and say oh, you went too far.

So one thing Python does not like is if
you reference a key before it exists.

We'll, we'll talk in a second how to
work around this. But if you simply

create a dictionary and say, oh, print out

what's under csev, it gives you a
traceback.

It's like,

I'm going to inform you that that's not
there.

And it says key error, csev.

Now, the thing that allows us to solve
this is the in operator.

We've used the in operator to see if a
substring was in a string.

Or if a number was in a list.

So, so this in operator says, in operator
says, hey, ask a question.

Is the string csev a current key in the
dictionary ccc?

Is the string csev a current key in the
dictionary ccc?

And it says, False.

So now we have something that doesn't give
a traceback

that can tell us whether or not the key is
there.

So if you remember the algorithm, the
first time you see it, you

set them to one, and every other time, you
add one to them.

So this is how we do that in Python.

So here's how we implement that program
that I just gave you

in Python. So, here's our names.

It's shorter so my slide works better.

Here's a variable, our iteration variable,
it's going to, you know,

go through all five of these one at a time.

And within the body of the
loop we have an if statement.

If the name is not currently in the

counts dictionary, counts is the name of
my dictionary.

If the name is not currently in the
counts dictionary,

I say counts sub name equals one.

else, that must mean it's already there
which means

it's okay to retrieve it, counts sub name
plus 1.

We're going to add a 1 to it and stick it
back in, okay?

And so when this finishes it's going to
add

entries and then add one to entries that
already exist.

And not traceback at all. And when we
print it out we're going to see the counts.

And literally this could have gone

a million times and it would just be fine
and it would just keep expanding.

Okay?

So this pattern of checking to see if a key

is in a dictionary, setting it to some
number, or

adding one to it is a really, really common
pattern.

It's so common, as a matter of fact, that
there is a

a special thing built into dictionaries
that does this for us, okay?

And there is this method called get.

And so, counts is the name of the
dictionary,

get is a built-in capability of
dictionaries.

And it takes two parameters.

The first parameter is a key name, like a
string, like csev or chen wen or marquard.

And then the second parameter is a value
to give back if this doesn't exist.

It's a default value if the key does not
exist.

And there's no traceback.

So this way you can encapsulate, in effect,
an if-then-else.

If the name parameter is in the counts,
print the thing out, otherwise print zero.

So this expression will either get the
number

if it exists or it will give me back a
zero if it doesn't exist.

So this is really valuable.

Right? This is really valuable.

That's a really bad smiley face.

So this is really valuable because it,
once, once we understand the idiom,

it really takes four lines of code and
turns it into one line of code.

Because we're going to be doing this
if-then-else all the time.

Now, and so we can reconstruct that loop

a lot easier and a lot more cleanly using this
idiom, right?

It's something that looks kind of complex
but you'll

get used to it really fast, okay?

So we have, everything here is the same,

we create an empty dictionary, we have five
names to

go through, we're going to write a
for loop

and it's going to go through each of
those.

And then we're going to say counts sub name
equals counts dot get the value stored

at name, and if you don't find it, give me
back a zero.

And then whatever comes back, either the
old value or

the zero, add 1 to that and then take that
sum and stick it in counts name.

Okay? So this is either

going to create,

or it's going to update.

If there is no entry, it's going to create
it and set it to one.

If there is an entry it's going to add one to
the current entry.

Okay? So this is,

this line is kind of an idiom.

Read about it in the book, figure it out,

get used to the notion of what this is doing.

Understand what that is doing, okay?

Because I'm going to start using it as if
you understand it.

So, the next problem is a problem of
finding the most common word.

So, finding the most common, the top

five, is often a, a trigger that says, use

dictionaries because if you're going to
have to count things up,

you're going to, you know, you don't

know what the most common thing is at the
beginning.

First you have to count everything up, and
dictionaries are a great way to count.

So here's a little problem and I would
like you to read

this text and find me the most common word
in the text.

And tell me what the most common word is
and how many times

it occurs. Ready?

I'm going to give you a thousandth of a
second, just like I would give a computer.

I would expect it'd be able to do this in
a thousandth of a second.

[SOUND] There you go.

[BLANK_AUDIO]

Okay, I gave you five seconds.
Time's up.

Did you get it?

Or did you say to yourself, you know what,
I hate

that, it's no good, I think I'll write a
Python program instead.

And he'll probably show me a Python
program if I wait long enough.

So here's a slightly easier problem from
the first lecture.

Ready?

It's the same problem.

Find the most common word and how many
times the word occurs.

[BLANK AUDIO]

[MUSIC]

Did you get it?
I believe the answer is, and I could look

really dumb here, oops, the answer is the,
and I think it's seven times.

So, that's the right answer. Okay?

Again, things humans are not so good at.

So, here's a piece of code that's starting
to combine some

of the things we've been doing in the past
few chapters all together.

We are going to read a line of text,

split it into words, count the occurrence,
how many times

each word occurs, and then print out a map.

So, so here's what we're going to do,
we're going to say okay, start

a dictionary, an empty dictionary, read
the line of input.

Then split it, remember, the split takes a
string and produces a list.

So words is a list, line is a string, and
then we'll print that out.

Then we're going to write a for loop
that's going to go

through each of the words, and
then create, use this idiom

counts sub word equals counts.get word, 0 + 1.

So this is going to do exactly what we talked
about in the previous

couple slides back, either create the
entries or add to those entries, okay?

And then we're going to print

them out.

So here's what that program does when it
prints out.

Now this is actually one long line I'm

just cutting it so you can see it.

Here's this line we enter, and the words
the, there's seven of them.

Then it takes this line and splits it into a

list, and there is the beginning and end
of the list.

The list maintains the order, so the

list simply breaks all these words into
separate

words in a list of strings.
From one string

to many strings. This is many strings.
And so the, and the spaces are gone.

And so now here's this list.

And then what we're going to do is we're
going to run through the list.

And we're going to keep running totals of
each of the words in the list.

And then when we're done with the list,

we're going to print out the contents of
that dictionary.

And we can inspect it and

go like, let's look for the biggest one,
na, na, na, na, na.

It's kind of like

looking for the largest, like, oh,
seven.

That's the largest and the largest word is
the.

Okay?

So that's how the program runs, it
reads a line,

splits it into a list of words, and then

accumulates a running total for each word,
and then we

hand inspect to see what the most common
word is.

Okay?

Oh no, no, I don't want that song again.

There we go.

And so and so here we have the, in it's
kind of a smaller fashion.

We make a dictionary.
This entering a line of text is here.

It's all one line.

We do the split and then we print the
words out.

And so that split creates a list of
strings from a single

string based on where the blanks are at,
chop, chop, chop, chop.

And then here

at counting,

we're going to loop through each of the
words one at a time and use this idiom,

counts sub word equals counts.get word, 0 + 1,
which is going to create and/or update.

And then we print the counts out and that
comes out there.

Okay?

So, again, this is the new thing that
we've done.

Everything else we've kind of seen before.

Now we can also loop through dictionaries
with for loops.

The for loop, we've been, put all kinds of
things over here.

We've put strings over here, we've put
lists of numbers over here.

We've put files over here.

And basically what it really says is you

know, if this is a collection of things,

run this little indent code once for
each item in

the collection, and key then becomes our
iteration variable.

And key is very mnemonic here.

It doesn't know that they are keys.

And so, keys.

The key here is that, there's a bit, the
important

concept here is that dictionaries are
key/value pairs and so this is

only one variable and so it actually
decides that, they've decided that

it goes through the keys, which is
actually quite useful.

So key is going to take on the successive
values of the labels.

Not the successive values of

the values stored at the labels.

But it's really easy for us to retrieve
the contents at that label counts sub key.

So we're going to use the key 'chuck',
'fred', 'jan', to look up the 1, 42, 100.

And so it prints out the key,

and then the value at it, the key, and the
value at it, and the key, and the value.

And so we're able to sort of go through

the dictionary and look at all the
key/value pairs,

which is the common thing that you really
want to do.

Okay?

Now there's some methods inside of
dictionaries that allow

us to convert dictionaries into lists
of things.

And so if you simply take a dictionary, so
here's a little dictionary with

three items in it, and we can say list sub
and then give a dictionary name

right there, and then that converts it
into a

list. But it's just a list of the keys.

We can also say jjj dot keys, kind of do
the same thing.

Say give me a list consisting of the keys.

And then jjj dot values gives you a list
of the values, 1, 42, and 100.

Of course they're not in the same order.

Now interestingly, as long as you don't
modify the dictionary,

the order of these two things corresponds
as long as

in between here you're not changing it.
So the first jan maps to 100,

chuck maps to 1,

and fred maps to 42.

So the order, you can't predict the order
they're

going to come out but these two things
will

come out in the same order, whatever that
order

happens to be. Okay, and so there's one
more thing.

So we've got the keys, we've got the
values, and we've got a thing called items.

items also returns a list, it's a list.
But it's a list of

what Python calls tuples.
That's what the next chapter is about.

We'll talk more about tuples in the next
chapter.

A tuple is a key/value pair.

So this list has three things in it.
One, two, three.

The first one jan maps to 100, the
second is chuck maps to 1, the

third one is fred maps to 42. So,
just kind of bear with me for a second.

We'll hit this a little harder in the next
chapter.

But the place that this, the idiom where

this works very beautifully is on a for
loop.

Now, for those of you who have programmed
in other languages, this will be

kind of weird because other languages have

iterations but they don't have two
iteration variables.

Python has two iteration variables.

It can be used for many things but one of the

things that it's used for that's really
quite nice is

we can have two iteration variables.
This jj items returns pairs of

things and then aaa and bbb are iteration
variables that sort of

move in synchronized, move, are
synchronized as they move through.

So aaa takes on the value of the key.

bbb takes on the value of the, the
value.

And then the loop runs once.

Then aaa is advanced to the next key.

And bbb is advanced to the next value
simultaneously, synchronized.

Then they print that out, then it advances
to the

next one, and the next one, and they print
that out.

So they are moving in a synchronized way.

Now again, the order jan, chuck, fred is not
the same.

But the correspondence between jan 100,

chuck 1, and fred,
that's going to, that's going to work.

And so basically, as these things go, they
work

their way through whatever order they're
stored in the dictionary.

So this is quite nice.

Two iteration variables going through
key/value.

Now if I was making these names mnemonic,
and they made more sense,

I would call this the key variable and
that would be the value variable.

But for now I'm just using kind of silly
names

to show you that key and value are not
special.

They're not Python reserved words in any
way.

They're just a good way to name these
things, key/value pairs.

Okay?

Okay.

Now we're going to circle all the way
back to the beginning.

All the way back to the first lecture.

And I gave you this program, and I said
don't worry about it.

We'll learn about it later.
Well, now later.

At this point you should be able to
understand every line of this program.

This is the program that's going to count
the most common word in a file.

Okay?

So let's walk through what it does and
hopefully

by now this will make a lot of sense.

Okay? So we're going to start out, we're
going to ask

for a file name, we're going to open that
file for read.

Then, because we know it's not a very large

file, we're going to read it all in one go.

So handle dot read says read the whole
file, newlines and all,

blanks, newlines, whatever,
and put it in

the variable called text, it's just
mnemonic. Remember I'm, in this one

I'm using the mnemonic variable names.
Then go through that whole

string, which was the whole file, go
through and split it all.

Newlines don't hurt it.
Newlines are treated like blanks.

And it understands all that.

It throws the newlines away and the
blanks away

and splits it into a beautiful list of
just words with no blanks.

And the list of the words in that file
ends up in the variable words.

words is a list, text is a string, words
is a list.

Then what I do is the pattern of
accumulating counters in a dictionary.

I make an empty dictionary.

I have the word variable that goes through
all the words

and then I just say, counts sub word equals
counts dot get(word,0) + 1,

and that, like we just got done saying,
it both creates

and/or increments the value in the
dictionary as needed.

So now at the end of the, at the, at this

point in the program, we have a full
dictionary with the word:count.

Okay?

And there's many of them.
You know, all the words, all the counts.

They're not in any particular order. So now what

we're going to do is we're going to write
a largest loop, find the largest.

Which is another thing that we've done.

So not only do I need to now know what
largest count I've seen so far,

I need to know what word that is.

So I'm going to set the largest count
we've seen so far to None, set

the largest word we've seen so far
to None, and then I'm going to use this

two-iteration variable pattern to say

go through the key/value pairs word and
count in counts.items.

So it's just going to

go through [SOUND] all of them.

And then I'm going to ask if the largest
number I've seen so far is None or

the current count that I'm looking at is
greater then the largest I've seen so far,

keep them. Take the current word, stick it
in biggest word so far,

take the current count, stick it in
the biggest count so far.

So this is going run through all of the

word.count pairs, word.count key/value pairs.

And then when it comes out, it's going to
print out

the word that's the most common and how
many times.

So if we feed in that clown text, it will
run all this stuff, and print out

oh, the is the most common word, and it
appeared seven times.

Or if I print the stuff that was two
slides back, words.txt, from the actual

textbook, then it says the word to is the
most common and it happened 16 times.

So I could easily, you know, throw 10
million, 10 million

words through this thing, and it would
just be totally happy.

Right? And so, this is not that complex

of a problem, but it's using a whole bunch
of idioms that we've been using.

The splitting of words, the accumulation
of multiple counters in a dictionary.

And so, it sort of is the beginning of
doing some kind of data

analysis that's hard for humans to do, and
error-prone for humans to do.

And so this is, we're reviewing collections.

We've introduced dictionaries.

We've done the most common word pattern,
talked about that.

The lack of order, and

I did that a bunch of times.

And we've looked ahead at tuples,
which is the next,

the third kind of collection that we're
going to talk about.

And they're actually in some ways a little
simpler than dictionaries.

And simpler than lists.

So, see you in the next lecture, Chapter
10, tuples.