1
00:00:05,540 --> 00:00:07,420
And if you looked at the Python source code

2
00:00:07,420 --> 00:00:09,760
in the past, you may have come across functions

3
00:00:09,760 --> 00:00:13,920
or methods with the parameters *args and **kwargs.

4
00:00:16,000 --> 00:00:20,220
Now usually pronounce star-args and star-star-kwargs

5
00:00:20,220 --> 00:00:23,400
or KW-args, depending on how you want to pronounce it.

6
00:00:23,400 --> 00:00:26,460
Now they look horrible, but they're actually quite simple

7
00:00:26,460 --> 00:00:28,010
once you know what they are.

8
00:00:28,010 --> 00:00:30,480
And more to the point, they're also very powerful

9
00:00:30,480 --> 00:00:31,950
and can give your functions and methods

10
00:00:31,950 --> 00:00:33,610
a lot of flexibility.

11
00:00:33,610 --> 00:00:36,680
Okay, so I don't want to mess up our jukebox programme,

12
00:00:36,680 --> 00:00:39,390
so I'm gonna create a new Python file to demonstrate this.

13
00:00:39,390 --> 00:00:42,060
We're gonna call that star_args.

14
00:00:45,560 --> 00:00:46,400
All right, let's enter some code

15
00:00:46,400 --> 00:00:48,090
and then have a look at what's going on.

16
00:00:48,090 --> 00:00:50,480
I'm gonna type print, left parentheses,

17
00:00:50,480 --> 00:00:53,920
a couple quotes, hello, then ending double-quotes,

18
00:00:53,920 --> 00:00:57,980
comma, space, and then double quotes again world,

19
00:00:57,980 --> 00:01:00,270
end double quotes and right parentheses.

20
00:01:00,270 --> 00:01:03,300
And no, you haven't ended up back at video one by mistake.

21
00:01:03,300 --> 00:01:07,160
So before I explain why we're printing hello world again,

22
00:01:07,160 --> 00:01:10,080
this isn't going to work for anyone using Python 2

23
00:01:10,080 --> 00:01:11,670
and you'll actually get an error.

24
00:01:11,670 --> 00:01:14,050
You can fix that by doing the following.

25
00:01:14,050 --> 00:01:15,490
This is if you're running Python 2.

26
00:01:15,490 --> 00:01:18,120
So from underscore underscore future,

27
00:01:18,120 --> 00:01:22,290
underscore underscore, import, print underscore function.

28
00:01:24,870 --> 00:01:27,700
Now this is a Python 3 course, so I'm not going to go

29
00:01:27,700 --> 00:01:30,790
into the great detail about Python 2,

30
00:01:32,060 --> 00:01:34,880
but I'm gonna point out things like this from time to time.

31
00:01:34,880 --> 00:01:37,840
So also useful if you have to work on Python 2 code,

32
00:01:37,840 --> 00:01:39,990
if you see that import, then you'll know

33
00:01:39,990 --> 00:01:44,330
it's making some Python 3 feature available in Python 2.

34
00:01:44,330 --> 00:01:47,100
So the underscore underscore future underscore underscore

35
00:01:47,100 --> 00:01:50,510
module was introduced in Python 2.1

36
00:01:50,510 --> 00:01:52,260
and you can find more information on that

37
00:01:52,260 --> 00:01:54,280
by Googling for Python, you guessed it,

38
00:01:54,280 --> 00:01:57,190
underscore underscore future underscore underscore.

39
00:01:57,190 --> 00:01:59,550
All right, but in this case, I'm gonna remove the import

40
00:01:59,550 --> 00:02:03,380
and that's because we're focusing on Python 3.

41
00:02:04,310 --> 00:02:06,120
So what are we doing with that load of code?

42
00:02:06,120 --> 00:02:07,910
Well, we're calling the print function

43
00:02:07,910 --> 00:02:10,479
and we're passing two strings to it.

44
00:02:10,479 --> 00:02:12,040
But we could pass more.

45
00:02:12,040 --> 00:02:15,260
And we've done that at various points in the course.

46
00:02:15,260 --> 00:02:19,900
So I can change that quite easily to hello planet

47
00:02:19,900 --> 00:02:23,320
then another comma, double quotes, earth.

48
00:02:24,480 --> 00:02:28,570
And if I run that, that still works quite nicely.

49
00:02:30,130 --> 00:02:32,120
Close that little warning down there.

50
00:02:32,120 --> 00:02:34,040
If I close down the run window

51
00:02:34,040 --> 00:02:37,280
and if I do the command click on a Mac

52
00:02:37,280 --> 00:02:39,810
but it's control on a PC, if I click on that

53
00:02:39,810 --> 00:02:43,300
and click on print and have a look.

54
00:02:43,300 --> 00:02:45,660
We can see the definitions in its source.

55
00:02:45,660 --> 00:02:48,370
Now this isn't the full source for the print function

56
00:02:48,370 --> 00:02:49,710
and that's because most of the stuff

57
00:02:49,710 --> 00:02:53,130
in builtins.py is actually written in C.

58
00:02:53,130 --> 00:02:56,730
So all we can see here is a stub showing the parameters.

59
00:02:56,730 --> 00:02:58,750
But that's enough to see that it doesn't list

60
00:02:58,750 --> 00:03:01,170
an infinite number of parameters to print.

61
00:03:01,170 --> 00:03:03,930
So instead, the first parameter, ignoring this self,

62
00:03:03,930 --> 00:03:06,840
is this *args that was talked about

63
00:03:06,840 --> 00:03:08,620
at the start of the video.

64
00:03:08,620 --> 00:03:11,710
Now that's the magic that lets a function or method

65
00:03:11,710 --> 00:03:14,600
take a variable number of arguments.

66
00:03:14,600 --> 00:03:17,830
So our three string values are wrapped up in a tuple,

67
00:03:17,830 --> 00:03:22,000
so args, or *args, is the unpacked values in that tuple.

68
00:03:23,090 --> 00:03:25,910
Args itself is a tuple, and the print function

69
00:03:25,910 --> 00:03:29,020
takes each item from the tuple and then prints it.

70
00:03:29,020 --> 00:03:31,090
Now as a result, it doesn't care how many arguments

71
00:03:31,090 --> 00:03:33,960
we provide, it just iterates over the tuple

72
00:03:33,960 --> 00:03:35,370
and prints them all.

73
00:03:35,370 --> 00:03:36,970
Now I'm not gonna point you at the relevant bit

74
00:03:36,970 --> 00:03:39,180
of the documentation for this just yet,

75
00:03:39,180 --> 00:03:40,810
because it all seems backwards.

76
00:03:40,810 --> 00:03:44,140
It states that the star operator unpacks the tuple.

77
00:03:44,140 --> 00:03:46,350
Now that's technically true, it does.

78
00:03:46,350 --> 00:03:48,450
And we'll actually see it doing that in a minute.

79
00:03:48,450 --> 00:03:52,110
But unfortunately, it offers that as the only explanation

80
00:03:52,110 --> 00:03:53,960
of how this works.

81
00:03:53,960 --> 00:03:56,390
So you end up thinking, hang on, I didn't pass a tuple,

82
00:03:56,390 --> 00:03:59,100
so how can star be unpacking it?

83
00:03:59,100 --> 00:04:01,620
A good way to work out how a lot of things

84
00:04:01,620 --> 00:04:04,000
in Python behaves is to experiment.

85
00:04:04,000 --> 00:04:05,640
So let's go back to our code.

86
00:04:05,640 --> 00:04:08,080
I'm gonna close down the builtins.py.

87
00:04:08,080 --> 00:04:09,500
And we're gonna create our own function

88
00:04:09,500 --> 00:04:11,840
that takes a variable number of arguments

89
00:04:11,840 --> 00:04:13,810
just to see how this works.

90
00:04:13,810 --> 00:04:15,970
Now I'm gonna keep the function really simple

91
00:04:15,970 --> 00:04:19,060
so that we can focus on the arguments.

92
00:04:19,060 --> 00:04:20,680
So we're just gonna calculate the average

93
00:04:20,680 --> 00:04:22,320
of a series of numbers.

94
00:04:22,320 --> 00:04:24,790
Now by average, I'm referring to the arithmetic mean,

95
00:04:24,790 --> 00:04:26,890
where you add up all the values and then divide by

96
00:04:26,890 --> 00:04:28,410
how many there are.

97
00:04:28,410 --> 00:04:30,730
So let's delete that first line.

98
00:04:30,730 --> 00:04:34,290
I'm gonna start with def space average

99
00:04:34,290 --> 00:04:36,620
parentheses, then the *args.

100
00:04:37,520 --> 00:04:40,720
Closing parentheses and colon.

101
00:04:40,720 --> 00:04:42,140
Mean equals zero.

102
00:04:42,980 --> 00:04:46,570
For arg in args colon mean plus equals arg.

103
00:04:51,230 --> 00:04:55,390
Then we're going to return mean divided by len args.

104
00:04:58,520 --> 00:05:00,200
Now obviously a very simple function.

105
00:05:00,200 --> 00:05:03,010
So let's see it calculate an average.

106
00:05:03,010 --> 00:05:05,460
So we're going to add the code to call it,

107
00:05:05,460 --> 00:05:09,030
so I print average and we're going to pass the numbers

108
00:05:09,030 --> 00:05:12,680
one space two space three space four,

109
00:05:12,680 --> 00:05:15,230
obviously end parentheses as well.

110
00:05:15,230 --> 00:05:19,400
So if we run that, over here we get the value 2.5.

111
00:05:21,340 --> 00:05:24,000
And incidentally, if you're using Python 2,

112
00:05:24,000 --> 00:05:26,900
you'll get the answer two, and that's because using

113
00:05:26,900 --> 00:05:31,780
the slash here in Python 2 performs integer division.

114
00:05:31,780 --> 00:05:33,670
And in Python 2 to correct that, you would actually

115
00:05:33,670 --> 00:05:37,840
come up and type in from underscore underscore future

116
00:05:40,300 --> 00:05:43,970
underscore underscore import division.

117
00:05:43,970 --> 00:05:46,220
That would actually fix it.

118
00:05:46,220 --> 00:05:47,730
That basically makes the slash behave

119
00:05:47,730 --> 00:05:50,790
in the same way as it does in Python 3.

120
00:05:50,790 --> 00:05:52,090
But I'm not gonna do that here obviously,

121
00:05:52,090 --> 00:05:56,000
because we're basically focusing on Python 3.

122
00:05:56,000 --> 00:05:58,130
And again, if you're using Python 2.1 or above,

123
00:05:58,130 --> 00:05:59,980
but not version 3, you'll need to leave

124
00:05:59,980 --> 00:06:02,020
that line in that I've just deleted.

125
00:06:02,020 --> 00:06:03,540
If you're maintaining Python 2 code,

126
00:06:03,540 --> 00:06:06,420
insert that import, you'll now know what it does.

127
00:06:06,420 --> 00:06:09,580
All right, so in getting back to our average function,

128
00:06:09,580 --> 00:06:11,380
let's add some diagnostic prints so that

129
00:06:11,380 --> 00:06:13,700
we can actually see what's going on.

130
00:06:13,700 --> 00:06:16,440
I'm gonna start by the line immediately

131
00:06:16,440 --> 00:06:17,890
after the definition.

132
00:06:17,890 --> 00:06:22,050
I'm gonna type print parentheses type parentheses args,

133
00:06:23,740 --> 00:06:25,090
closing parentheses.

134
00:06:25,090 --> 00:06:28,290
I'm gonna do print, parentheses, double quote,

135
00:06:28,290 --> 00:06:31,120
args is left and right curly brace

136
00:06:32,950 --> 00:06:37,120
colon double quote dot format args in parentheses,

137
00:06:38,620 --> 00:06:40,110
closing parentheses.

138
00:06:40,110 --> 00:06:43,280
And print *args double quotes is colon

139
00:06:46,370 --> 00:06:50,540
double quote comma then *args, then right parentheses.

140
00:06:51,420 --> 00:06:55,160
So let's actually run that and see what answer we get.

141
00:06:55,160 --> 00:06:57,880
So we can see that the top of args is a tuple.

142
00:06:57,880 --> 00:07:01,540
And printing the args results in the typical output we get

143
00:07:01,540 --> 00:07:03,290
when we print a tuple.

144
00:07:03,290 --> 00:07:05,580
The print function encloses it in parentheses,

145
00:07:05,580 --> 00:07:07,920
as you can see here, so we've got args

146
00:07:07,920 --> 00:07:09,970
is one, two, three, four.

147
00:07:09,970 --> 00:07:13,510
And printing *args gives the four separate values

148
00:07:13,510 --> 00:07:15,630
one, two, three, and four.

149
00:07:15,630 --> 00:07:18,690
So you can see that the star operator, the asterisk,

150
00:07:18,690 --> 00:07:22,490
has unpacked the args tuple on line four

151
00:07:22,490 --> 00:07:25,730
when we printed that out or using the star here.

152
00:07:25,730 --> 00:07:28,070
But we didn't pass in a tuple,

153
00:07:28,070 --> 00:07:30,660
we provided four separate values.

154
00:07:30,660 --> 00:07:33,930
So *args in the functions parameters up here,

155
00:07:33,930 --> 00:07:37,940
on line one, that represents the unpacked tuple,

156
00:07:37,940 --> 00:07:42,110
which means that args without the star is the tuple.

157
00:07:42,110 --> 00:07:44,940
So that is to say that the *args parameter

158
00:07:44,940 --> 00:07:47,810
is telling Python to expect an unpacked tuple

159
00:07:47,810 --> 00:07:50,030
and the values we provide will be packed

160
00:07:50,030 --> 00:07:52,830
into the parameter called args.

161
00:07:52,830 --> 00:07:54,590
And just to show that, if we actually remove

162
00:07:54,590 --> 00:07:56,090
the asterisk here.

163
00:07:58,530 --> 00:08:01,360
And run, we actually get an error.

164
00:08:03,790 --> 00:08:05,680
Positional argument but four were given.

165
00:08:05,680 --> 00:08:09,600
Sorry, takes one positional argument, but four were given.

166
00:08:09,600 --> 00:08:12,860
So if we don't specify that the parameter is *args,

167
00:08:12,860 --> 00:08:14,540
what we're doing is we're forcing anything

168
00:08:14,540 --> 00:08:18,000
that caused the function to put the values in parentheses

169
00:08:18,000 --> 00:08:21,540
to pass them all as a single tuple value.

170
00:08:21,540 --> 00:08:25,020
So we could do that, we could change our line 10 here

171
00:08:25,020 --> 00:08:26,710
and put another set of parentheses

172
00:08:26,710 --> 00:08:28,880
around those four numbers.

173
00:08:30,460 --> 00:08:35,400
If we run that, you can see we get it working again.

174
00:08:35,400 --> 00:08:39,080
And notice that the printout from line four

175
00:08:39,080 --> 00:08:42,520
has successfully unpacked our args tuple.

176
00:08:42,520 --> 00:08:45,080
So it's true to say that star or the asterisk

177
00:08:45,080 --> 00:08:48,020
unpacks a tuple, but that's not what it's doing

178
00:08:48,020 --> 00:08:50,030
when it appears as a parameter.

179
00:08:50,030 --> 00:08:52,170
In that case, it's used to represent the fact

180
00:08:52,170 --> 00:08:54,600
that the arguments will be an unpacked tuple,

181
00:08:54,600 --> 00:08:58,250
so they'll be packed into the args parameter.

182
00:08:58,250 --> 00:09:00,510
So there are a couple of things to note about this.

183
00:09:00,510 --> 00:09:02,430
The first is the name args.

184
00:09:02,430 --> 00:09:04,050
Now you can use any name you want,

185
00:09:04,050 --> 00:09:05,970
as long as obviously it's a valid path

186
00:09:05,970 --> 00:09:07,720
and variable name, of course.

187
00:09:07,720 --> 00:09:10,370
The convention now is to call it args,

188
00:09:10,370 --> 00:09:12,630
which is an abbreviation for arguments.

189
00:09:12,630 --> 00:09:14,360
Now unless you've got a very good reason,

190
00:09:14,360 --> 00:09:16,140
and frankly I can't think of one,

191
00:09:16,140 --> 00:09:17,740
then stick to the convention.

192
00:09:17,740 --> 00:09:19,400
And that's because it makes it much easier

193
00:09:19,400 --> 00:09:22,100
for other people to read your code.

194
00:09:22,100 --> 00:09:25,620
The second is that a variadic parameter,

195
00:09:25,620 --> 00:09:27,420
as the documentation calls this,

196
00:09:27,420 --> 00:09:30,840
must appear after all other positional parameters.

197
00:09:30,840 --> 00:09:34,380
So it basically scoops up the remaining positional arguments

198
00:09:34,380 --> 00:09:36,110
to quote the documentation.

199
00:09:36,110 --> 00:09:37,760
So in other words, you can't do something like this,

200
00:09:37,760 --> 00:09:38,990
this wouldn't work.

201
00:09:38,990 --> 00:09:42,440
So we couldn't change this to put first underscore value

202
00:09:42,440 --> 00:09:45,770
comma and space and then our *args again

203
00:09:46,680 --> 00:09:49,550
comma last underscore value.

204
00:09:49,550 --> 00:09:51,210
The first argument in that case would go

205
00:09:51,210 --> 00:09:53,630
to first underscore value, but then all

206
00:09:53,630 --> 00:09:55,190
the remaining positional arguments

207
00:09:55,190 --> 00:09:57,660
will end up in args, which leaves no way

208
00:09:57,660 --> 00:10:00,140
to provide a value for the last underscore value

209
00:10:00,140 --> 00:10:03,260
without using a named keyword parameter.

210
00:10:03,260 --> 00:10:04,680
So if we try that

211
00:10:07,630 --> 00:10:11,800
we get an error and then even if I fix the code on line 10

212
00:10:13,040 --> 00:10:16,370
and run it again, we still get an error.

213
00:10:19,840 --> 00:10:22,530
Missing one required keyword-only argument,

214
00:10:22,530 --> 00:10:24,840
last underscore value.

215
00:10:24,840 --> 00:10:27,170
I might just move this down,

216
00:10:28,780 --> 00:10:30,960
so I can read these errors a little bit easier.

217
00:10:30,960 --> 00:10:32,400
Okay.

218
00:10:32,400 --> 00:10:35,200
So if anything does follow the args, the *args,

219
00:10:35,200 --> 00:10:38,170
it has to be a set of keyword parameters.

220
00:10:38,170 --> 00:10:41,660
And we're gonna look at those in the next video, actually.

221
00:10:41,660 --> 00:10:42,660
Right, so I'm gonna finish this video

222
00:10:42,660 --> 00:10:44,060
with a short challenge.

223
00:10:44,060 --> 00:10:46,220
Let's have a look at that.

224
00:10:52,050 --> 00:10:54,380
All right, so the challenge is to write a function

225
00:10:54,380 --> 00:10:58,380
called build_tuple, that takes a variable number

226
00:10:58,380 --> 00:11:01,400
of arguments, and returns a tuple containing

227
00:11:01,400 --> 00:11:03,530
the values passed to it.

228
00:11:03,530 --> 00:11:05,550
Now the image below shows some sample input

229
00:11:05,550 --> 00:11:09,000
to the function and also the expected output.

230
00:11:09,000 --> 00:11:11,520
So pause the video if you wanna see what that is.

231
00:11:11,520 --> 00:11:16,250
Actually, I'll show it on the next slide anyway.

232
00:11:16,250 --> 00:11:18,760
Now the function itself isn't particularly useful.

233
00:11:18,760 --> 00:11:21,330
The aim here is to test your understanding

234
00:11:21,330 --> 00:11:23,550
of what we've just done, not to produce something

235
00:11:23,550 --> 00:11:25,700
that you're likely to use.

236
00:11:25,700 --> 00:11:29,020
And as a hint, it will be a very short function.

237
00:11:29,020 --> 00:11:30,200
All right, so that's your challenge.

238
00:11:30,200 --> 00:11:31,810
See how you go, pause the video,

239
00:11:31,810 --> 00:11:34,830
and I'll see you when you get back.

240
00:11:34,830 --> 00:11:36,410
All right, so how did you get on?

241
00:11:36,410 --> 00:11:38,020
Did you manage to get it to work?

242
00:11:38,020 --> 00:11:39,770
Well, let's actually have a go at doing that.

243
00:11:39,770 --> 00:11:43,940
I'm going to delete our code in this stars_args.py file.

244
00:11:46,780 --> 00:11:50,250
And we'll start with def space build

245
00:11:50,250 --> 00:11:52,660
underscore tuple *args colon.

246
00:11:57,030 --> 00:11:59,700
Then I'm just gonna return args.

247
00:12:01,000 --> 00:12:02,500
That's actually it.

248
00:12:02,500 --> 00:12:04,900
That's because when you provide a variable list

249
00:12:04,900 --> 00:12:08,130
of arguments to a function, they're packed into a tuple,

250
00:12:08,130 --> 00:12:09,780
so this function is probably the shortest one

251
00:12:09,780 --> 00:12:11,040
you're ever gonna write.

252
00:12:11,040 --> 00:12:12,990
All we have to do is literally return args,

253
00:12:12,990 --> 00:12:14,990
sorry without the colon.

254
00:12:15,930 --> 00:12:16,760
So that's it.

255
00:12:16,760 --> 00:12:18,760
If you managed to solve the challenge, well done.

256
00:12:18,760 --> 00:12:21,470
And if you're not sure how this function works,

257
00:12:21,470 --> 00:12:24,010
it's probably worth rewatching this video.

258
00:12:24,010 --> 00:12:26,590
But to what I'm going to do is just put

259
00:12:26,590 --> 00:12:28,150
some code in here, just so we can test it

260
00:12:28,150 --> 00:12:29,940
as I mentioned in the video.

261
00:12:29,940 --> 00:12:32,990
And what I'm gonna do is just copy that code in,

262
00:12:32,990 --> 00:12:34,990
save a bit of time here.

263
00:12:36,320 --> 00:12:39,690
Just to confirm that it does actually work, like so.

264
00:12:39,690 --> 00:12:43,790
So again, now if we run this, you can see

265
00:12:43,790 --> 00:12:47,080
that we've got the expected output down below.

266
00:12:47,080 --> 00:12:49,690
So again, if you're not sure how this function works,

267
00:12:49,690 --> 00:12:52,350
it's definitely worth reviewing this video again

268
00:12:52,350 --> 00:12:54,430
and trying to write some other functions

269
00:12:54,430 --> 00:12:56,910
that also take variable number of arguments

270
00:12:56,910 --> 00:12:59,820
and just to test your theories out.

271
00:13:00,900 --> 00:13:03,790
Now examples you might wanna try here is

272
00:13:03,790 --> 00:13:06,860
firstly, a function that takes a variable number of words,

273
00:13:06,860 --> 00:13:09,270
then returns the average word length,

274
00:13:09,270 --> 00:13:11,110
a function that returns the smallest or largest

275
00:13:11,110 --> 00:13:13,820
of the numbers passed to it, a function to print

276
00:13:13,820 --> 00:13:17,250
all the words passed to it backwards in reverse order,

277
00:13:17,250 --> 00:13:20,470
so the output will read correctly from right to left.

278
00:13:20,470 --> 00:13:23,150
And a hint for that one is, we saw how to reverse a string

279
00:13:23,150 --> 00:13:26,380
using a slice of left to right square brackets,

280
00:13:26,380 --> 00:13:29,120
two colons, negative one, and that can also

281
00:13:29,120 --> 00:13:30,880
have a use with tuples.

282
00:13:30,880 --> 00:13:34,400
Another example, create a list, let's say you call it words.

283
00:13:34,400 --> 00:13:36,920
Then print the list, but also print *words

284
00:13:36,920 --> 00:13:40,770
to see that star can also be used to unpack a list

285
00:13:40,770 --> 00:13:42,350
as well as a tuple.

286
00:13:45,750 --> 00:13:47,940
The documentation for all of this is on the link

287
00:13:47,940 --> 00:13:51,610
listed on the screen and it's also in the resources section.

288
00:13:51,610 --> 00:13:53,660
It's worth reviewing that section down to,

289
00:13:53,660 --> 00:13:57,960
but not including, 4.7.5 Lambda Expressions.

290
00:13:57,960 --> 00:13:59,500
And you'll also find an image showing

291
00:13:59,500 --> 00:14:02,620
my version of those functions in the resources section

292
00:14:02,620 --> 00:14:06,050
for this video, just to help you out.

293
00:14:06,050 --> 00:14:08,910
So I won't show those images here.

294
00:14:08,910 --> 00:14:10,390
I'll leave that for you to check out

295
00:14:10,390 --> 00:14:11,880
so that you've got a chance to attempt

296
00:14:11,880 --> 00:14:13,470
those functions first.

297
00:14:13,470 --> 00:14:16,350
So see how you go with that, and if you do get stuck,

298
00:14:16,350 --> 00:14:19,000
or you wanna confirm your answers, check out the image

299
00:14:19,000 --> 00:14:20,940
that again is available in the resources section

300
00:14:20,940 --> 00:14:22,370
for this video.

301
00:14:22,370 --> 00:14:24,950
So with that said, I'm going to end the video here now.

302
00:14:24,950 --> 00:14:28,180
In the next video, we're gonna look at the KW-args

303
00:14:28,180 --> 00:14:30,900
or kwargs, as people like to pronounce it.

304
00:14:30,900 --> 00:14:33,850
which is also another term for keyword parameters.

305
00:14:33,850 --> 00:14:36,680
So I'll see you in the next video.

