Eventually, you're going to be in a situation where you need to

use a pattern on 100 different items in a big loop.

Or maybe it'll be 500, or 1000.

You don't wanna have to build and match the pattern every single time.

So the regular expression library has given us a way to compile a pattern into

an object that we can match against.

Let's look at how to do that.

We've already seen that we can make patterns as strings.

We stored them as a variable back, way, way back in the first video.

But, that's not really the most useful thing in the world.

I mean like, if we have, say this string, yeah, it's handy having this as

a variable, but it doesn't save us a lot of time or trouble.

It'd be better if we could say that pattern in a state where it

was ready to go.

It's ready to be used as a regular expression.

And we can do that.

That's what the Compile method let's us do.

So that's actually change line here.

Instead of Search, we'll wanna say Compile.

And what that does is this is gonna take the regular expression and compile it,

get it ready for use.

Now the one other thing we have to change, is we have to take out where it says data.

Because when we compile a regular expression,

we don't compile it with the data it's gonna be run against.

It's like making the regular expression a bit more generic.

We can now run it against a lot of different things.

Not just the one thing that we did the search against, or the match or whatever.

So, I'm gonna take out this line one and let's look at this one.

So we've got line.groupdict and

that no longer makes sense because line isn't a match.

So let's go ahead and do a match.

We'll do re.search, line, data, and then groupdict.

So what we did here, is we created a regular expression search,

just like before, and we said, okay, your pattern is this compiled one, it's line.

And the string you're gonna match it against is data.

And now notice, we didn't specify any flags.

You specify the flags when you do the compile, not when you do the search.

So let's save that and let's Run.

And there we go, we got that same thing.

So, that's great.

But what's really, really, really cool,

at least I think so, is we don't have to do this re.search stuff.

What we can do, instead, is we can just use line directly.

[BLANK_AUDIO]

So we can just say, okay, take line.

It's a pattern. We know it's a pattern.

Do a search with it against data.

So let's take that out.

Run this again, and we should get the exact same content, and we do.

So, that's pretty cool.

But, we've only got one thing.

We're only, we're only getting my line.

How do we get the rest of the lines?

Well, this is the last part of the r-a library that I wanna go over with you.

But there's still more in there to explore.

Go check the docs.

They're awesome.

It's a method that's named finditer.

And it gives us back an iterable of each non-overlapping match.

It's kind of like giving us back a list, but it's not exactly a list.

It's also kinda like using Find All, but instead of getting back topples,

we get back a match object, like when we use re.match or re.search.

So let's try this out.

Let's come back up here and let's say for

match in line.search, oops sorry.

Not line.search.

Line.finditer against data.

We want to print match.group.

Name.

So, this .group method,

when you have a match object says, show me whatever is inside of the group.

Now, I can say, group with a, with nothing, and

it'll show me the whole thing that it captures.

I can do group with a number, and it'll show me the group at that index.

So, 0, 1, 2, so on.

Or I can give it a name and it'll show me the group at that name.

All right, so let's try that out.

So there we go.

There's everybody's names.

You can see Ryan Carson, The Doctor, Exampleson, Example, so on.

All right, that's all of our names.

We can of course ask for any group that we want or do all sorts of other stuff.

For example, let's make a fully qualified email to headers.

You, you've seen this before where it's like a name and then less than,

their email address and greater than, right?

Okay, so before we do that,

I want to actually come back and edit our pattern, and add two things.

So what's cool is we can have subpatterns, or subgroups, sorry.

So we can do here last, and that's the last name.

And we can do here first, and that of course is the first name.

So there's our first name, there's our last name, as these little sub patterns.

'Kay?

So now in our.

For loop, we need to print out a new thing.

And let's print out first, last, email.

'Kay.

And we wanna format this.

With the match.groupdict.

Right? It'll go ahead and

find those keys in the groupdict, it'll use those as keyword arguments.

All right, so let's try this out, we should have email addresses for everybody.

Check it out, we've got email addresses.

There's the name, and an email address.

That works pretty well, and it's a lot simpler than I

would have actually expected it to be if you were just like hey,

turn this into a bunch of email addresses.

Hopefully this will give you some ideas on how to take our address book further.

You can build all sorts of things out of dictionaries.

Made from strings through regular expressions.

In this course, compiling our pattern doesn't actually save us a lot of time or

memory, but it's a good habit to get into, so

you won't forget to do it when it actually matters.

And using things like finditer helps us to save even more memory.

Compiling patterns also lets you make patterns available for

import in other parts of your applications, or even in other packages.

This way, you can make your pattern as perfect as possible in just one place and

reap the benefits anywhere else that you need it.

I think we're done.

We've gone over pretty much every area of regular expressions in Python, and

we've turned a block of text that no one would want to wade through into super

useful dictionaries that we can put into classes or transform into a new text file.

In fact, that's your extra credit for this course.

Take the regex we wrote and the text and make a class for

a person to find by the data.

Give them names and a phone number and an email address.

Maybe make another class for an address book that collects all these

people together and let's the user search them.

Be sure to share it on the forums.

Thanks so much for being part of this course.

I'll see you next time.