Preview
Video Player
00:00
00:00
Executable
7:14Dig into how dunder main works when importing code into another file.
Hello again, in this video we're going
to dig into Dunder main some more and
0:00
why it's useful.
0:04
Let's pop back into dm.py If
you're not there already and
0:06
look at our new Dunder main.
0:09
Now the if here at the start lets us know
that this is a conditional statement.
0:12
It's checking this Dunder name or
double underscore name value and
0:18
seeing if it's equal to
the string Dunder main.
0:23
If it is,
then what is inside of it will run.
0:28
If it's not, then it will not.
0:32
Now we can actually print out this
Dunder name to see what it is.
0:35
So I'm gonna put a couple of spaces here.
0:39
And we're just gonna do a print statement.
0:42
And let's do dunder name.
0:45
dm.py's value.
0:50
And then I'm just gonna copy this line and
0:53
do the same thing over here in app.py.
0:58
And then we gonna make sure we
change this to app.py's value.
1:03
Okay, perfect.
1:08
So now we're gonna run both files and see
what that Dunder name value comes out to.
1:09
So I'm gonna start with running
dm.py on its own, python3 dm.py.
1:14
And you can see I get Dunder
main is dm.py's value,
1:22
which means this will evaluate to true,
this conditional.
1:26
So then this print statement
gets printed to the console.
1:31
Now let's check it out in app.py.
1:36
I'm gonna make the terminal
a little bit bigger here, okay
1:40
Okay, so now you can see it's running
dm.py first, so we still get that
1:47
initial print statement where we're
checking the Dunder name value.
1:52
And you can see dm.py's named value is
now dm, which is the name of our file.
1:57
Which makes our conditional
no longer true,
2:04
which means this print
statement no longer runs.
2:07
Then it comes over here to our app.py and
2:11
it prints out this line saying that
app.py's value is now Dunder main.
2:15
And then we also get our print
statement from inside of this file.
2:20
So when you run a file
In the console directly,
2:25
its Dunder name value becomes Dunder main.
2:29
So that is how we use Dunder main or
2:34
this conditional statement to control
what executes in your code so
2:37
only the elements you want to run
can run and those you don't, won't.
2:43
Let's talk best practices with an example.
2:50
In modules or
files that are meant to be imported,
2:54
you wanna hold most of your code
inside of functions or classes.
2:58
And I'm gonna model this
with a simple recipe.
3:03
We're just gonna make a pretend
peanut butter and jelly sandwich.
3:06
So I'm gonna call this one,
3:09
gather_ingredients.
3:14
And I'm just gonna do a print
3:18
statement that says Bread, jelly,
3:22
and peanut butter gathered, okay?
3:27
And then we're gonna do a second one and
I'm gonna call
3:34
it combine_ingredients to
another print statement.
3:39
And inside of here we're gonna do,
3:44
Add peanut butter and
3:49
jelly to slices and put them together.
3:52
Awesome, now inside of our Dunder main,
if I wanted to I could
3:58
test out my functions by
putting gather_ingredients and
4:03
combine_ingredients function
calls down here.
4:09
So that while I was playing around or
testing or
4:13
just working on my code in this file,
when I run it directly,
4:17
you can see I get the correct responses.
4:22
But if I run app.py,
4:25
I don't get anything printed
to the console from dm.py, so
4:32
it doesn't clutter up my console.
4:36
Now, another best practice
is to place all function
4:40
calls inside of another
function called main.
4:46
So it would look something like this.
4:51
And then we would switch these two out,
For main.
4:57
And now if I run it in the console,
I'm just gonna do up arrow.
5:05
I'll get the same response from dm.py and
app.py.
5:08
Exact same thing, nothing from dm.py runs
because this is inside of our Dunder main.
5:12
Now this file,
5:19
our dm.py can be imported without
the worry of something running on its own.
5:20
But like you saw, we can also run this
file by itself to make sure things
5:25
are working correctly inside of dm.py.
5:29
The goal of Dunder main is to keep your
console and program under control.
5:32
Inside of dm.py or sorry, inside of
app.py, we could now, if I remove these,
5:37
I can either do dm.gather_ingredients
to call that function.
5:43
Or to make things even simpler,
I now only have to call this
5:49
one function and
it runs everything inside of dm.py for me.
5:54
So now if I do, let me clear the console,
just make this.
5:59
Oops, forgot to write the whole word.
6:02
There we go.
6:04
Now, if I run app.py you'll see,
I get those two statements printed out.
6:07
But you can see we call our function
main here inside of our Dunder main,
6:13
which also calls those two functions
that print those things out,
6:19
those statements, but
they don't get printed out to the console
6:24
because Dunder main is saying, hey,
this is not true, so don't do this.
6:29
So now we only have two statements
printed to the console instead of getting
6:35
cluttered with four.
6:40
So what I'm saying is if we didn't
have this by comment this out,
6:42
And then run app.py,
you can see now we get four printed out.
6:48
And you can imagine over time and
6:52
the larger your program is that would
become really annoying to have all these
6:53
statements coming from all
these different files.
6:57
So instead, we use Dunder main
to keep things under control.
7:01
So in the next video, I'm going to
give you a challenge to try and
7:06
incorporate Dunder main on your own.
7:10
See you there.
7:13