1
00:00:00,000 --> 00:00:00,000
Hello guys.

2
00:00:00,000 --> 00:00:03,000
So we are going to continue the discussion with respect to Python.

3
00:00:03,000 --> 00:00:06,000
And now we are going to see some of the examples already.

4
00:00:06,000 --> 00:00:10,000
In our previous video we saw many topics regarding uh functions.

5
00:00:10,000 --> 00:00:12,000
And uh, there are a lot of advanced topics that are going to come.

6
00:00:12,000 --> 00:00:17,000
But before that I thought, why not create some examples and show you how we can probably solve those.

7
00:00:17,000 --> 00:00:18,000
Right.

8
00:00:18,000 --> 00:00:22,000
So first example over here is that we need to create a function for temperature conversion.

9
00:00:22,000 --> 00:00:27,000
So temperature conversion basically means we need to convert Celsius to Fahrenheit or Fahrenheit to

10
00:00:27,000 --> 00:00:27,000
Celsius.

11
00:00:27,000 --> 00:00:29,000
So how do we define a function?

12
00:00:29,000 --> 00:00:30,000
We'll go ahead and see.

13
00:00:30,000 --> 00:00:32,000
So let's go ahead and see this example.

14
00:00:32,000 --> 00:00:34,000
So first of all I will go ahead and create my function.

15
00:00:34,000 --> 00:00:37,000
Let's say I will write convert underscore temperature.

16
00:00:37,000 --> 00:00:40,000
So this is my function over here.

17
00:00:40,000 --> 00:00:42,000
And here I will give two parameters.

18
00:00:42,000 --> 00:00:46,000
One is temperature and one is the unit that I really want to convert it.

19
00:00:46,000 --> 00:00:52,000
Let's say if I give the unit over here as c, that basically means I need to convert this, uh, this

20
00:00:52,000 --> 00:00:55,000
entire temperature from Celsius to Fahrenheit.

21
00:00:55,000 --> 00:00:56,000
Right?

22
00:00:56,000 --> 00:00:59,000
And if I give the unit as F, right.

23
00:00:59,000 --> 00:01:03,000
So I need to convert the temperature from Fahrenheit to Celsius, right.

24
00:01:03,000 --> 00:01:06,000
So let me just go ahead and give a docstring.

25
00:01:06,000 --> 00:01:07,000
So this function.

26
00:01:09,000 --> 00:01:17,000
Converts temperature between Celsius.

27
00:01:18,000 --> 00:01:20,000
and Fahrenheit.

28
00:01:20,000 --> 00:01:21,000
Okay.

29
00:01:21,000 --> 00:01:27,000
So, uh, this is what is my definition of, uh, this particular function over here.

30
00:01:27,000 --> 00:01:30,000
And, uh, we will go ahead and write our code.

31
00:01:30,000 --> 00:01:30,000
Right.

32
00:01:30,000 --> 00:01:35,000
So here let's say I will go ahead and write if unit is double equal to capital C.

33
00:01:35,000 --> 00:01:36,000
Right.

34
00:01:36,000 --> 00:01:41,000
If I'm giving this particular unit, that basically means I need to convert my temperature from Celsius

35
00:01:41,000 --> 00:01:41,000
to Fahrenheit.

36
00:01:41,000 --> 00:01:47,000
So I'm going to return a temperature multiplied by, and I'll do the operation nine by five.

37
00:01:47,000 --> 00:01:48,000
Okay.

38
00:01:48,000 --> 00:01:51,000
And here let me just give the bracket nine by five.

39
00:01:51,000 --> 00:01:54,000
Uh oh sorry I need to first of all multiply it.

40
00:01:54,000 --> 00:01:57,000
Then I will go ahead and do the addition plus 32.

41
00:01:57,000 --> 00:02:03,000
So this is the formula of converting a Celsius to Fahrenheit with respect to the temperature okay.

42
00:02:03,000 --> 00:02:05,000
So this is the simple formula that we specifically use.

43
00:02:05,000 --> 00:02:13,000
And this in turn will be converting Celsius to Fahrenheit okay.

44
00:02:13,000 --> 00:02:16,000
Foreign Fahrenheit.

45
00:02:16,000 --> 00:02:16,000
Okay.

46
00:02:16,000 --> 00:02:20,000
Then uh, let me go ahead and write Elif.

47
00:02:20,000 --> 00:02:20,000
Okay.

48
00:02:20,000 --> 00:02:24,000
So here we are going to use everything, whatever things you have learned, let's say there are some

49
00:02:24,000 --> 00:02:28,000
examples where I'm going to use dictionaries, some examples where I'm going to use, uh, list and

50
00:02:28,000 --> 00:02:29,000
all.

51
00:02:29,000 --> 00:02:32,000
In this particular case, you can probably see that I'm also using if Elif.

52
00:02:32,000 --> 00:02:33,000
Right.

53
00:02:33,000 --> 00:02:38,000
So if, uh, Elif, the unit is double equal to Fahrenheit.

54
00:02:38,000 --> 00:02:40,000
Okay, then I'm going to basically return.

55
00:02:40,000 --> 00:02:41,000
Okay.

56
00:02:41,000 --> 00:02:48,000
And with for this particular temperature, I need to minus first of all, 32 and then multiply it by

57
00:02:48,000 --> 00:02:49,000
five by nine.

58
00:02:50,000 --> 00:02:50,000
Okay.

59
00:02:50,000 --> 00:02:55,000
And this will basically give us uh, our Fahrenheit to Celsius.

60
00:02:55,000 --> 00:02:55,000
Right.

61
00:02:55,000 --> 00:02:56,000
So this is the formula.

62
00:02:56,000 --> 00:03:02,000
If you go ahead and do the Google search also to convert uh, Celsius to Fahrenheit.

63
00:03:02,000 --> 00:03:04,000
So this is the formula that you usually get.

64
00:03:04,000 --> 00:03:04,000
Okay.

65
00:03:04,000 --> 00:03:07,000
So uh, that's it.

66
00:03:07,000 --> 00:03:08,000
This is what it is right.

67
00:03:08,000 --> 00:03:14,000
And if I don't give any information for our third parameter we need to also handle that.

68
00:03:14,000 --> 00:03:15,000
That is if I'm not giving any unit.

69
00:03:15,000 --> 00:03:17,000
So I will just go ahead and return.

70
00:03:17,000 --> 00:03:18,000
None okay.

71
00:03:18,000 --> 00:03:18,000
Okay.

72
00:03:18,000 --> 00:03:19,000
None.

73
00:03:20,000 --> 00:03:20,000
So done.

74
00:03:20,000 --> 00:03:23,000
So here I'm going to basically use this function.

75
00:03:23,000 --> 00:03:26,000
Now let me go ahead and call this function as convert temperature.

76
00:03:26,000 --> 00:03:32,000
And if I go ahead and write like a value let's say temperature I'm going to give 25.

77
00:03:32,000 --> 00:03:32,000
Right.

78
00:03:32,000 --> 00:03:34,000
And this is in Celsius.

79
00:03:34,000 --> 00:03:35,000
Right.

80
00:03:35,000 --> 00:03:38,000
Uh then I'm going to go ahead and print it.

81
00:03:38,000 --> 00:03:38,000
Right.

82
00:03:38,000 --> 00:03:41,000
And I will be basically getting converted.

83
00:03:41,000 --> 00:03:45,000
We are converting this from 29 degree Celsius to Fahrenheit.

84
00:03:45,000 --> 00:03:48,000
The next one that I'm actually going to do is print.

85
00:03:48,000 --> 00:03:48,000
Okay.

86
00:03:48,000 --> 00:03:52,000
Again, I will go ahead and call my convert temperature.

87
00:03:52,000 --> 00:03:56,000
And here I'm actually going to give 77 comma F.

88
00:03:56,000 --> 00:03:57,000
Right.

89
00:03:57,000 --> 00:03:58,000
And this I will be able to get the answer.

90
00:03:58,000 --> 00:04:00,000
Let's see whether it works.

91
00:04:00,000 --> 00:04:07,000
Yes 25 is nothing but 77 of degree Fahrenheit and 77 degree Fahrenheit is nothing but 25 degree Celsius.

92
00:04:07,000 --> 00:04:09,000
So this is how the conversion is done.

93
00:04:09,000 --> 00:04:11,000
And I feel that formula is absolutely right.

94
00:04:11,000 --> 00:04:11,000
What you have.

95
00:04:11,000 --> 00:04:11,000
Right.

96
00:04:12,000 --> 00:04:16,000
Um, and here you can just see based on units we are able to do it.

97
00:04:16,000 --> 00:04:18,000
So this is our first example.

98
00:04:18,000 --> 00:04:23,000
Um, now what I'm actually going to do is that I'm going to show you one more amazing example, which

99
00:04:23,000 --> 00:04:26,000
is called as password strength checker.

100
00:04:26,000 --> 00:04:26,000
Okay.

101
00:04:26,000 --> 00:04:28,000
Now what exactly is this?

102
00:04:28,000 --> 00:04:31,000
Uh, let's say that we are creating our user ID or login.

103
00:04:31,000 --> 00:04:34,000
And over there we specifically give passwords.

104
00:04:34,000 --> 00:04:34,000
Right?

105
00:04:34,000 --> 00:04:38,000
And it is a and most of the people just write password as 12345.

106
00:04:38,000 --> 00:04:41,000
So we need to have a strong password check okay.

107
00:04:41,000 --> 00:04:46,000
So I'll be giving some of the check over here to just uh, making you understand whether it is a weak

108
00:04:46,000 --> 00:04:49,000
password or a true or a, uh, very strong password.

109
00:04:49,000 --> 00:04:50,000
Right.

110
00:04:50,000 --> 00:04:55,000
So first of all, I will go ahead and write my definition is strong password.

111
00:04:55,000 --> 00:05:01,000
So this function will be responsible in checking whether a password is strong or not okay.

112
00:05:02,000 --> 00:05:05,000
So here you can see I will just go ahead and write my docstring.

113
00:05:05,000 --> 00:05:13,000
This function checks if the password is strong or not.

114
00:05:13,000 --> 00:05:13,000
Mm.

115
00:05:14,000 --> 00:05:15,000
Okay.

116
00:05:16,000 --> 00:05:21,000
Now let me go ahead and write let's say first condition that first criteria I want to put with respect

117
00:05:21,000 --> 00:05:22,000
to the password.

118
00:05:22,000 --> 00:05:25,000
My password should be minimum of eight character.

119
00:05:25,000 --> 00:05:25,000
Right.

120
00:05:25,000 --> 00:05:34,000
So I will go ahead and write if length of if length of password is less than eight is less than eight.

121
00:05:34,000 --> 00:05:39,000
So that basically means I'm going to just say, hey, this is a very bad password in short.

122
00:05:39,000 --> 00:05:45,000
So I'll just go and say false because this, uh, function that I'm actually creating is basically checking

123
00:05:45,000 --> 00:05:46,000
whether a password is strong or not.

124
00:05:46,000 --> 00:05:48,000
So right now the password is not strong.

125
00:05:48,000 --> 00:05:49,000
So I'm returning false.

126
00:05:49,000 --> 00:05:52,000
Then let me just go ahead and write another condition.

127
00:05:52,000 --> 00:05:53,000
If not okay.

128
00:05:53,000 --> 00:05:57,000
So if not is one condition if not any okay.

129
00:05:57,000 --> 00:06:02,000
So here we are just going to see whether this character is having any digit or not.

130
00:06:02,000 --> 00:06:03,000
Right.

131
00:06:03,000 --> 00:06:07,000
Whatever character whatever password we are specifically giving whether it is having any digit or not.

132
00:06:07,000 --> 00:06:08,000
Right.

133
00:06:08,000 --> 00:06:14,000
So what I'm actually going to do, if not, is basically like comparing whether there is not present

134
00:06:14,000 --> 00:06:15,000
or not.

135
00:06:15,000 --> 00:06:15,000
Right.

136
00:06:15,000 --> 00:06:16,000
Something like that.

137
00:06:16,000 --> 00:06:20,000
So I will go ahead and use a for loop for character in password.

138
00:06:20,000 --> 00:06:23,000
So we will go ahead and see each and every character.

139
00:06:23,000 --> 00:06:28,000
And here I will just go ahead and see whether this character is having any digit or not.

140
00:06:28,000 --> 00:06:28,000
Okay.

141
00:06:28,000 --> 00:06:33,000
So each digit is a function that is present in every characters or string.

142
00:06:33,000 --> 00:06:34,000
right?

143
00:06:34,000 --> 00:06:39,000
So I'm going to compare for every character in this specific password, whether it is having a digit

144
00:06:39,000 --> 00:06:39,000
or not.

145
00:06:39,000 --> 00:06:40,000
Right.

146
00:06:40,000 --> 00:06:43,000
If there is not any digits right.

147
00:06:43,000 --> 00:06:45,000
So what I will do I will again return false.

148
00:06:45,000 --> 00:06:46,000
Okay.

149
00:06:46,000 --> 00:06:50,000
Please see carefully what kind of condition I'm using.

150
00:06:50,000 --> 00:06:50,000
Right.

151
00:06:50,000 --> 00:06:55,000
So this is just like a any function or an inbuilt function that is present in Python.

152
00:06:55,000 --> 00:06:59,000
And we are iterating through each and every characters in that password, and we are seeing whether

153
00:06:59,000 --> 00:07:00,000
it is a digit or not.

154
00:07:00,000 --> 00:07:01,000
Right.

155
00:07:01,000 --> 00:07:05,000
And this is digit is a kind of function that is available in strings.

156
00:07:05,000 --> 00:07:05,000
Okay.

157
00:07:05,000 --> 00:07:07,000
So this is one of the check that I really want to do.

158
00:07:07,000 --> 00:07:08,000
Right.

159
00:07:08,000 --> 00:07:12,000
Then I will also be checking with respect to the password is lower.

160
00:07:12,000 --> 00:07:19,000
If all the characters is lower then also we should return it false saying that hey it is not exactly

161
00:07:19,000 --> 00:07:20,000
a good password, right?

162
00:07:20,000 --> 00:07:21,000
So I will go ahead and write.

163
00:07:21,000 --> 00:07:22,000
If not any.

164
00:07:22,000 --> 00:07:25,000
Again I will go ahead and write my next condition.

165
00:07:25,000 --> 00:07:30,000
And here this time I will say hey for cat and password.

166
00:07:30,000 --> 00:07:32,000
And here I'm going to check.

167
00:07:32,000 --> 00:07:32,000
Right.

168
00:07:32,000 --> 00:07:34,000
And what I have to check over here.

169
00:07:34,000 --> 00:07:37,000
Whether my character is lower.

170
00:07:37,000 --> 00:07:41,000
So low is lower is one of the function that is again present in Python.

171
00:07:41,000 --> 00:07:43,000
Sorry for character in password I have to write.

172
00:07:43,000 --> 00:07:44,000
Okay.

173
00:07:44,000 --> 00:07:49,000
Uh, I'm just checking whether the character is lower or not for all the characters that are present

174
00:07:49,000 --> 00:07:49,000
over there.

175
00:07:49,000 --> 00:07:53,000
And if it is present, I'm just going to return the false.

176
00:07:53,000 --> 00:07:53,000
Okay.

177
00:07:54,000 --> 00:07:56,000
So guys, now we have written the condition still here.

178
00:07:56,000 --> 00:08:00,000
We have also checked, uh, like all the characters should not be lowercase.

179
00:08:00,000 --> 00:08:00,000
Okay.

180
00:08:00,000 --> 00:08:07,000
Now, uh, similarly all the characters should also not be, you know, uppercase, you know, and,

181
00:08:07,000 --> 00:08:09,000
uh, we'll also check for that.

182
00:08:09,000 --> 00:08:09,000
Right.

183
00:08:09,000 --> 00:08:14,000
So here I'm going to write if, if not in if not any.

184
00:08:14,000 --> 00:08:17,000
And this time I will be using cat.

185
00:08:17,000 --> 00:08:19,000
Dot is upper right.

186
00:08:19,000 --> 00:08:25,000
So there are a lot of functions with respect to strings which I can specifically use over here.

187
00:08:25,000 --> 00:08:30,000
And let me just go ahead and write for cat in password okay.

188
00:08:31,000 --> 00:08:36,000
And this we will go ahead and check it out and we'll again write return false.

189
00:08:36,000 --> 00:08:37,000
Okay.

190
00:08:37,000 --> 00:08:38,000
Now this is there.

191
00:08:38,000 --> 00:08:41,000
Now let's think of more things, you know.

192
00:08:41,000 --> 00:08:44,000
Uh, let's see for any special characters.

193
00:08:44,000 --> 00:08:51,000
So for special character, uh, I would like to add many special characters that are probably present,

194
00:08:51,000 --> 00:08:51,000
right.

195
00:08:51,000 --> 00:08:57,000
If not any, let's say in our character, if there is no special character like this, then also I can

196
00:08:57,000 --> 00:09:01,000
say that, hey, this is basically a weak password, right?

197
00:09:01,000 --> 00:09:03,000
At least it should have one upper.

198
00:09:03,000 --> 00:09:08,000
You know, at least it should have one digits, you know, so this kind of condition.

199
00:09:08,000 --> 00:09:11,000
So here I've used all special characters over here for character in password.

200
00:09:11,000 --> 00:09:15,000
And then if it is not present we are just going to return false.

201
00:09:15,000 --> 00:09:20,000
If everything satisfies uh, then we will go ahead and return true.

202
00:09:20,000 --> 00:09:21,000
Okay.

203
00:09:21,000 --> 00:09:23,000
So here all return false are there.

204
00:09:23,000 --> 00:09:25,000
And then here return true is there.

205
00:09:25,000 --> 00:09:25,000
Right.

206
00:09:25,000 --> 00:09:30,000
So if all this condition are false, then, uh, if all this condition does not get satisfied, then

207
00:09:30,000 --> 00:09:31,000
we are just going to return true.

208
00:09:31,000 --> 00:09:36,000
Saying that, hey, this is super amazing password and it is a strong password.

209
00:09:36,000 --> 00:09:38,000
Now let me just go ahead and call the function.

210
00:09:38,000 --> 00:09:41,000
So calling the function over here okay.

211
00:09:41,000 --> 00:09:45,000
And uh let me just give some of the things over here.

212
00:09:45,000 --> 00:09:45,000
Right.

213
00:09:45,000 --> 00:09:51,000
So I'll go ahead and write print ease, underscore strong password.

214
00:09:51,000 --> 00:09:53,000
And let me just give one example.

215
00:09:53,000 --> 00:09:55,000
Let's say I have a capital letter.

216
00:09:55,000 --> 00:09:58,000
And I will write a small letter again a capital letter.

217
00:09:58,000 --> 00:10:00,000
And this is V password okay.

218
00:10:00,000 --> 00:10:05,000
But here you can see that I'm not having any special character or uh, other than that I think everything

219
00:10:05,000 --> 00:10:07,000
is getting satisfied.

220
00:10:07,000 --> 00:10:07,000
Right.

221
00:10:07,000 --> 00:10:08,000
And digit is also not there.

222
00:10:08,000 --> 00:10:11,000
So I should definitely be getting false for this.

223
00:10:11,000 --> 00:10:16,000
One more way is that I can go ahead and print okay is strong password.

224
00:10:16,000 --> 00:10:20,000
And let me just go ahead and use some special characters.

225
00:10:20,000 --> 00:10:26,000
So I will go ahead and write str and let me just go ahead and use uh zero over here.

226
00:10:26,000 --> 00:10:27,000
Okay.

227
00:10:27,000 --> 00:10:33,000
And I will be using ng capital P w d and let me use one special character like exclamation.

228
00:10:33,000 --> 00:10:34,000
Okay.

229
00:10:34,000 --> 00:10:39,000
Now let's see whether both of them I think this should basically be giving me false, and this should

230
00:10:39,000 --> 00:10:40,000
be giving me true.

231
00:10:40,000 --> 00:10:45,000
Okay, so now if I execute this here, you can see since I do not have a digit or a special character,

232
00:10:45,000 --> 00:10:48,000
I'm actually getting false here.

233
00:10:48,000 --> 00:10:52,000
I have both uh, a digit and a special character.

234
00:10:52,000 --> 00:10:56,000
So and that is the reason I am also having a capital letter over here.

235
00:10:56,000 --> 00:10:57,000
So that is the reason I'm getting true.

236
00:10:57,000 --> 00:11:02,000
So this is one amazing example with respect to password strength checker.

237
00:11:02,000 --> 00:11:07,000
Just with the help of one function, we are able to do this kind of, uh, validation and we are able

238
00:11:07,000 --> 00:11:08,000
to execute it.

239
00:11:08,000 --> 00:11:09,000
Okay.

240
00:11:09,000 --> 00:11:13,000
Now uh, let's go with the third example.

241
00:11:13,000 --> 00:11:19,000
Now this specific example, I have actually selected, uh, just to make sure to show you like, uh,

242
00:11:19,000 --> 00:11:21,000
how in the real world application this can be used.

243
00:11:21,000 --> 00:11:26,000
So calculate the total cost of items in a shopping cart.

244
00:11:26,000 --> 00:11:28,000
So here we are going to define a function.

245
00:11:28,000 --> 00:11:34,000
So I will go ahead and write def calculate underscore total underscore cost.

246
00:11:35,000 --> 00:11:37,000
And here I'm going to give my cart okay.

247
00:11:37,000 --> 00:11:43,000
Now this cart will basically be having a lot of uh you know items over there.

248
00:11:43,000 --> 00:11:46,000
And we can also give in the form of dictionary.

249
00:11:46,000 --> 00:11:52,000
So right now I'm just going to do pass because first of all I'll see what kind of data I have okay.

250
00:11:52,000 --> 00:11:56,000
So let's just go ahead and show you some of the example with respect to card data.

251
00:11:56,000 --> 00:11:59,000
And since we have already learned about dictionary.

252
00:11:59,000 --> 00:12:03,000
So we will go ahead and write cart is equal to and we'll create a list.

253
00:12:03,000 --> 00:12:05,000
And this will be a list of dictionaries okay.

254
00:12:05,000 --> 00:12:13,000
So let's say my first item is something like with key value pairs like name is equal to uh let's say

255
00:12:13,000 --> 00:12:14,000
I have Apple.

256
00:12:15,000 --> 00:12:15,000
Okay.

257
00:12:15,000 --> 00:12:21,000
Then I have price which is equal to 0.5.

258
00:12:22,000 --> 00:12:25,000
Then I have specifically quantity okay.

259
00:12:26,000 --> 00:12:29,000
And this quantity will be equal to four.

260
00:12:29,000 --> 00:12:29,000
Okay.

261
00:12:30,000 --> 00:12:34,000
Uh now I will go ahead and create my next, uh example.

262
00:12:34,000 --> 00:12:39,000
And let's say this point $5 I will written like that, right?

263
00:12:39,000 --> 00:12:40,000
Obviously.

264
00:12:40,000 --> 00:12:43,000
So here let me just go ahead and and name should be banana.

265
00:12:43,000 --> 00:12:44,000
Okay.

266
00:12:44,000 --> 00:12:46,000
Price will be point $3.

267
00:12:46,000 --> 00:12:50,000
Let's say quantity I'll say six six bananas.

268
00:12:50,000 --> 00:12:51,000
This is the price.

269
00:12:51,000 --> 00:12:56,000
And let me just go ahead and again add one more item over here.

270
00:12:56,000 --> 00:12:56,000
Right.

271
00:12:58,000 --> 00:13:01,000
Now let me just go ahead and write one more like orange.

272
00:13:01,000 --> 00:13:02,000
Okay.

273
00:13:02,000 --> 00:13:07,000
The price will be 0.7 and quantity I can write as three.

274
00:13:07,000 --> 00:13:08,000
Okay.

275
00:13:08,000 --> 00:13:10,000
So this is my cart okay.

276
00:13:10,000 --> 00:13:16,000
With respect to all the items that I have, then I will just go ahead and write my function over here.

277
00:13:16,000 --> 00:13:18,000
So let me just go ahead and create a temporary variable.

278
00:13:18,000 --> 00:13:20,000
Total cost is equal to zero.

279
00:13:20,000 --> 00:13:22,000
Now all I have to do is that I have to explore.

280
00:13:22,000 --> 00:13:25,000
I have to probably go through this each and every cart.

281
00:13:25,000 --> 00:13:28,000
Uh, take the price.

282
00:13:28,000 --> 00:13:28,000
Okay.

283
00:13:28,000 --> 00:13:32,000
And see, uh, this price is basically for one quantity.

284
00:13:32,000 --> 00:13:33,000
Okay.

285
00:13:33,000 --> 00:13:37,000
So we will go ahead and multiply with this many number of quantities okay.

286
00:13:37,000 --> 00:13:40,000
And again we have to retrieve the data from this particular dictionary.

287
00:13:40,000 --> 00:13:42,000
And then we will be doing the total sum okay.

288
00:13:42,000 --> 00:13:46,000
So now let me just go ahead and write and write from item in cart.

289
00:13:46,000 --> 00:13:48,000
So I will go ahead and explore this okay.

290
00:13:49,000 --> 00:13:50,000
So I will just go ahead and write.

291
00:13:50,000 --> 00:13:55,000
Total cost is equal to or plus equal to okay.

292
00:13:55,000 --> 00:13:58,000
So just like an increment operation where we are adding something.

293
00:13:58,000 --> 00:14:02,000
Then here I'm going to write item of price okay.

294
00:14:02,000 --> 00:14:03,000
Item of price.

295
00:14:03,000 --> 00:14:11,000
So this for every item of price we are just going to multiply with the item of quantity okay.

296
00:14:11,000 --> 00:14:14,000
So let me just go ahead and write it down.

297
00:14:14,000 --> 00:14:16,000
Then I'll be getting my total cost.

298
00:14:16,000 --> 00:14:19,000
Uh, then I can go ahead and return the total cost.

299
00:14:19,000 --> 00:14:25,000
So this function is just going to multiply the price with respect to all the quantity for each and every

300
00:14:25,000 --> 00:14:26,000
item.

301
00:14:26,000 --> 00:14:28,000
Now quickly let me just go ahead and call the function.

302
00:14:28,000 --> 00:14:33,000
So here I'm going to write calling the function okay.

303
00:14:33,000 --> 00:14:39,000
And here I will write total underscore cost is equal to calculate total cost.

304
00:14:39,000 --> 00:14:42,000
And here I'm going to give my data as cart.

305
00:14:42,000 --> 00:14:45,000
Now let's go ahead and execute it I'll press shift enter.

306
00:14:46,000 --> 00:14:48,000
And here uh okay.

307
00:14:48,000 --> 00:14:52,000
Let me just go ahead and print this total cost because we have not displayed anything.

308
00:14:52,000 --> 00:14:55,000
Now here you can see 5.889.

309
00:14:55,000 --> 00:14:59,000
So this is my total cost right.

310
00:14:59,000 --> 00:15:02,000
With respect to all the items that I have actually bought okay.

311
00:15:02,000 --> 00:15:07,000
And this is amazing I'm able to see the total cost of my entire cart.

312
00:15:07,000 --> 00:15:10,000
So here we have just created a function which is taking that cart.

313
00:15:10,000 --> 00:15:12,000
Items and cart can be given as a dictionary.

314
00:15:12,000 --> 00:15:14,000
List whatever things you really want.

315
00:15:14,000 --> 00:15:17,000
Then we'll iterate through each and everything and we'll calculate the cost.

316
00:15:18,000 --> 00:15:18,000
Perfect.

317
00:15:18,000 --> 00:15:21,000
Uh, let's go ahead and see one more example.

318
00:15:21,000 --> 00:15:26,000
Uh, this time, what we are basically going to do over here is that we are going to check or we are

319
00:15:26,000 --> 00:15:31,000
going to create a function which will be checking if a string is palindrome.

320
00:15:31,000 --> 00:15:33,000
Now what does palindrome basically mean?

321
00:15:33,000 --> 00:15:38,000
So if you just want to understand about palindrome, write some of the examples.

322
00:15:38,000 --> 00:15:40,000
Let's say if I use this string a b a.

323
00:15:40,000 --> 00:15:44,000
If you read it from the front direction it is a b a.

324
00:15:44,000 --> 00:15:48,000
If you read it from the backward direction, it is again a b a only right?

325
00:15:48,000 --> 00:15:50,000
So from front and back both are same.

326
00:15:50,000 --> 00:15:51,000
Okay.

327
00:15:51,000 --> 00:15:56,000
So we are going to basically write a function which will be able to do the check for any string from

328
00:15:56,000 --> 00:16:01,000
whether from the front it is equal and from the back it is equal with respect to the characters that

329
00:16:01,000 --> 00:16:01,000
we have.

330
00:16:01,000 --> 00:16:02,000
It should be same.

331
00:16:02,000 --> 00:16:03,000
Okay.

332
00:16:03,000 --> 00:16:05,000
So here, uh, let us go ahead and define a function.

333
00:16:05,000 --> 00:16:08,000
So I'm going to write is underscore palindrome.

334
00:16:08,000 --> 00:16:11,000
So I'll just go ahead and write.

335
00:16:11,000 --> 00:16:13,000
My function is underscore palindrome.

336
00:16:13,000 --> 00:16:16,000
And here I'm going to give my string okay.

337
00:16:16,000 --> 00:16:16,000
Okay.

338
00:16:16,000 --> 00:16:23,000
Now the best way to do is that whatever string I write right between all the spaces.

339
00:16:23,000 --> 00:16:24,000
First of all, I should remove it.

340
00:16:25,000 --> 00:16:26,000
So I'll take the string.

341
00:16:26,000 --> 00:16:30,000
I'll write s dot lower because I have to also do the lowering of all the characters.

342
00:16:30,000 --> 00:16:33,000
And let me just replace all the empty string.

343
00:16:34,000 --> 00:16:34,000
Okay.

344
00:16:34,000 --> 00:16:36,000
With a string.

345
00:16:36,000 --> 00:16:36,000
Right?

346
00:16:36,000 --> 00:16:39,000
With like I should just remove that empty spaces.

347
00:16:40,000 --> 00:16:47,000
Now the best way to do this is that I hope everybody knows in string we have, uh, discussed about,

348
00:16:47,000 --> 00:16:49,000
uh, you know, slicing operations and all.

349
00:16:49,000 --> 00:16:51,000
So I will just go ahead and right.

350
00:16:51,000 --> 00:16:51,000
Colon.

351
00:16:51,000 --> 00:16:53,000
Colon minus one.

352
00:16:53,000 --> 00:16:53,000
Okay.

353
00:16:53,000 --> 00:16:58,000
Now, if this string is, uh, if I'm.

354
00:16:58,000 --> 00:17:02,000
See, this is what I'm getting the reverse of a string, right?

355
00:17:02,000 --> 00:17:06,000
If I'm writing this particular code, I just need to compare this with my s, right?

356
00:17:06,000 --> 00:17:11,000
So if I go ahead and write s double equal to, this will either give true or false.

357
00:17:11,000 --> 00:17:15,000
This is basically the reverse of this specific string itself, right?

358
00:17:15,000 --> 00:17:19,000
So if both of them are equal then we can definitely say that it is a palindrome.

359
00:17:19,000 --> 00:17:24,000
Now let us go ahead and see here uh I will go ahead and call this palindrome.

360
00:17:24,000 --> 00:17:26,000
Now I in in Google.

361
00:17:26,000 --> 00:17:29,000
Also you can search for different different uh text.

362
00:17:29,000 --> 00:17:30,000
Right.

363
00:17:30,000 --> 00:17:39,000
So I will use a sentence which is called as a man a plan a canal Panama.

364
00:17:39,000 --> 00:17:40,000
Okay.

365
00:17:40,000 --> 00:17:42,000
Now if you read from here.

366
00:17:42,000 --> 00:17:42,000
Right.

367
00:17:42,000 --> 00:17:45,000
And if you read from the reverse, it is almost same.

368
00:17:45,000 --> 00:17:46,000
See a man.

369
00:17:46,000 --> 00:17:46,000
Right.

370
00:17:46,000 --> 00:17:49,000
So if it is starting from a man.

371
00:17:49,000 --> 00:17:54,000
So here also from backwards, if I read a man is over here right.

372
00:17:54,000 --> 00:17:55,000
Then again a plan.

373
00:17:55,000 --> 00:17:58,000
So A is over here and plan is still here, right?

374
00:17:58,000 --> 00:18:01,000
So I if you read this particular sentence, it is reverse.

375
00:18:01,000 --> 00:18:02,000
Again it is almost same.

376
00:18:02,000 --> 00:18:03,000
Right.

377
00:18:03,000 --> 00:18:04,000
So let's go ahead and print this.

378
00:18:04,000 --> 00:18:09,000
And next one I will just go ahead and take one sentence which is not palindrome.

379
00:18:09,000 --> 00:18:11,000
So let me just go ahead and write hello.

380
00:18:11,000 --> 00:18:17,000
So in hello case I don't have the same sentence from forward or backward right.

381
00:18:17,000 --> 00:18:17,000
It is not equal.

382
00:18:17,000 --> 00:18:21,000
So first one should be giving me true and second one should be giving me false.

383
00:18:21,000 --> 00:18:22,000
So here you can see it is true.

384
00:18:22,000 --> 00:18:24,000
And the second one is basically false.

385
00:18:24,000 --> 00:18:28,000
So this is one amazing example with respect to palindrome.

386
00:18:28,000 --> 00:18:34,000
And just by using this string operation slicing operation how easily you are able to do it.

387
00:18:34,000 --> 00:18:35,000
Okay.

388
00:18:35,000 --> 00:18:40,000
Now the next example that we are basically going to see is something called as factorial of a number

389
00:18:40,000 --> 00:18:41,000
using recursion.

390
00:18:41,000 --> 00:18:42,000
Now what is recursion?

391
00:18:42,000 --> 00:18:44,000
Recursion is nothing but I.

392
00:18:44,000 --> 00:18:49,000
If I create a function, that function inside, the body of that function will be called again and again.

393
00:18:49,000 --> 00:18:53,000
Okay, and if I talk about factorials, let's say I want to calculate five factorial.

394
00:18:53,000 --> 00:18:59,000
So it is nothing but five into four into three into two into one.

395
00:18:59,000 --> 00:18:59,000
Right.

396
00:18:59,000 --> 00:19:02,000
So this basically is the operation of any factorials.

397
00:19:02,000 --> 00:19:03,000
Right.

398
00:19:03,000 --> 00:19:06,000
So I have to write a function which will be factorial.

399
00:19:06,000 --> 00:19:09,000
And let's say I have given I want the factorial for five.

400
00:19:09,000 --> 00:19:09,000
Right.

401
00:19:09,000 --> 00:19:16,000
So first condition will be that if n is equal to zero right then what I need to do, I just need to

402
00:19:16,000 --> 00:19:17,000
return one.

403
00:19:17,000 --> 00:19:17,000
Right.

404
00:19:17,000 --> 00:19:20,000
Because five into four into three into one right.

405
00:19:20,000 --> 00:19:21,000
So three into two into one.

406
00:19:21,000 --> 00:19:22,000
It should be like that.

407
00:19:22,000 --> 00:19:24,000
If I'm starting from five it should end till one.

408
00:19:24,000 --> 00:19:28,000
So if n becomes zero I need to just return one okay.

409
00:19:28,000 --> 00:19:36,000
Else I will go ahead and just use one simple return n multiplied by factorial n minus one.

410
00:19:36,000 --> 00:19:37,000
Right.

411
00:19:37,000 --> 00:19:41,000
So here I am calling this particular function right.

412
00:19:41,000 --> 00:19:43,000
So initially if I give five right.

413
00:19:43,000 --> 00:19:44,000
So what will happen.

414
00:19:44,000 --> 00:19:45,000
This condition will become false.

415
00:19:45,000 --> 00:19:49,000
So it will just go ahead and write five multiplied by factorial of four.

416
00:19:49,000 --> 00:19:51,000
Then again factorial of four.

417
00:19:51,000 --> 00:19:56,000
When it is called it will be four into factorial of three, then three into factorial of two, then

418
00:19:56,000 --> 00:19:59,000
two into factorial of one, then one into factorial of zero.

419
00:19:59,000 --> 00:20:02,000
When zero comes, return one, so it will be multiplied by one, right?

420
00:20:02,000 --> 00:20:06,000
So now if I just go ahead and call the function, it will be nothing.

421
00:20:06,000 --> 00:20:10,000
But I can just go ahead and write factorial with respect to phi.

422
00:20:10,000 --> 00:20:13,000
And here you can see this is my output.

423
00:20:13,000 --> 00:20:16,000
If I want factorial for six this is the output.

424
00:20:16,000 --> 00:20:18,000
Here you can see that I am able to get it right.

425
00:20:18,000 --> 00:20:20,000
And this is what is called as recursion.

426
00:20:20,000 --> 00:20:24,000
In recursion inside a function you are calling the same function.

427
00:20:24,000 --> 00:20:27,000
Unless and until based on this condition it will keep on executing.

428
00:20:27,000 --> 00:20:28,000
Okay.

429
00:20:29,000 --> 00:20:34,000
Uh, so there are two more examples of function to read a file and count the frequency of the word.

430
00:20:34,000 --> 00:20:39,000
Okay, I know I have not discussed much about file operation yet.

431
00:20:39,000 --> 00:20:44,000
Okay, but I really want to show you like, let's say that I have one file over here.

432
00:20:44,000 --> 00:20:47,000
Sample text I have written two line of code.

433
00:20:47,000 --> 00:20:48,000
Hello, world.

434
00:20:48,000 --> 00:20:48,000
How are you?

435
00:20:48,000 --> 00:20:49,000
My name is Krish.

436
00:20:49,000 --> 00:20:50,000
Okay.

437
00:20:50,000 --> 00:20:55,000
Uh, as we go ahead, we'll be discussing more about, uh, reading file and doing file operation.

438
00:20:55,000 --> 00:21:00,000
But here I just want to give you an example, like how we can create a function to this do this task

439
00:21:00,000 --> 00:21:01,000
okay.

440
00:21:01,000 --> 00:21:02,000
So first of all what I'll do.

441
00:21:02,000 --> 00:21:08,000
Uh, so my task is very simple over here I will try to read a file and count the frequency of each word.

442
00:21:08,000 --> 00:21:08,000
Right.

443
00:21:08,000 --> 00:21:10,000
So how many times each word is present?

444
00:21:10,000 --> 00:21:11,000
Okay.

445
00:21:11,000 --> 00:21:18,000
So quickly we will go ahead and write definition count underscore word underscore frequency okay.

446
00:21:19,000 --> 00:21:22,000
And now I'm just going to give my file path.

447
00:21:23,000 --> 00:21:27,000
Uh the best way to read file path is by using with open function.

448
00:21:27,000 --> 00:21:32,000
Open function is there in Python where you can specifically use and open any kind of file.

449
00:21:33,000 --> 00:21:35,000
So I will go ahead and write word underscore count.

450
00:21:35,000 --> 00:21:38,000
And I know that since I need to count the frequency of each word.

451
00:21:38,000 --> 00:21:40,000
So I need a dictionary over here.

452
00:21:40,000 --> 00:21:42,000
So this will be an empty dictionary.

453
00:21:42,000 --> 00:21:47,000
Now I'll go ahead and write with open my file underscore path.

454
00:21:47,000 --> 00:21:50,000
And this will open in my read mode okay.

455
00:21:50,000 --> 00:21:53,000
So for read mode I will give it in string okay.

456
00:21:53,000 --> 00:21:58,000
And there is also like write mode and all which will be discussing as we go ahead in the upcoming sessions.

457
00:21:58,000 --> 00:22:01,000
And then we will go ahead and write as file.

458
00:22:01,000 --> 00:22:04,000
Then we will go ahead and write for line in file.

459
00:22:04,000 --> 00:22:04,000
Okay.

460
00:22:05,000 --> 00:22:11,000
And we are just going to write words is equal to line dot split okay.

461
00:22:12,000 --> 00:22:13,000
Line dot split.

462
00:22:13,000 --> 00:22:17,000
So we are splitting it based on new line characters.

463
00:22:17,000 --> 00:22:22,000
We are uh going through this particular file right with respect to that.

464
00:22:22,000 --> 00:22:27,000
Okay, now, once I get the words right, once we by using this particular line of code, we will be

465
00:22:27,000 --> 00:22:33,000
getting words because every space it will try to calculate it will split it and it will retrieve all

466
00:22:33,000 --> 00:22:34,000
these words.

467
00:22:34,000 --> 00:22:35,000
Okay.

468
00:22:35,000 --> 00:22:40,000
Now once we get the words, what I will do is that I will go ahead and write for words in word.

469
00:22:40,000 --> 00:22:41,000
Okay.

470
00:22:41,000 --> 00:22:48,000
And here I'm going to basically write word is equal to word dot lower.

471
00:22:48,000 --> 00:22:49,000
Okay.

472
00:22:49,000 --> 00:22:50,000
So I'm going to do the lower operation.

473
00:22:50,000 --> 00:22:55,000
First of all I really need to make small uh for all the words.

474
00:22:55,000 --> 00:22:55,000
Okay.

475
00:22:55,000 --> 00:23:01,000
Then uh, let's say I want to probably do dot strip operation.

476
00:23:01,000 --> 00:23:02,000
Okay.

477
00:23:02,000 --> 00:23:05,000
And if you don't know about dot strip, uh, you'll be able to understand.

478
00:23:05,000 --> 00:23:12,000
Whenever I give any specific words, it should be able to split based on any kind of characters because

479
00:23:12,000 --> 00:23:13,000
I need each and every word.

480
00:23:13,000 --> 00:23:19,000
So I'll be using some special characters like colon slash, exclamation, everything.

481
00:23:19,000 --> 00:23:22,000
I'll be using this even, um, like it should.

482
00:23:22,000 --> 00:23:24,000
It should also split h e also separately.

483
00:23:24,000 --> 00:23:24,000
Right.

484
00:23:24,000 --> 00:23:26,000
So that is the reason I've given this also.

485
00:23:26,000 --> 00:23:29,000
And if there is exclamation everything, I'll try to strip it.

486
00:23:29,000 --> 00:23:31,000
And uh, I will try to get the word okay.

487
00:23:31,000 --> 00:23:37,000
Then I will just go ahead and write word of count and I will take that specific word.

488
00:23:37,000 --> 00:23:38,000
Okay.

489
00:23:38,000 --> 00:23:39,000
Please focus on the logic.

490
00:23:39,000 --> 00:23:40,000
Okay?

491
00:23:40,000 --> 00:23:41,000
Logic is super important.

492
00:23:41,000 --> 00:23:44,000
And logic, you become better when you keep on practicing.

493
00:23:44,000 --> 00:23:48,000
Then I'm going to write word underscore count dot get.

494
00:23:48,000 --> 00:23:55,000
And here I'm going to write word comma zero okay word comma zero.

495
00:23:55,000 --> 00:23:59,000
And then we are going to add it with one okay.

496
00:23:59,000 --> 00:24:06,000
So I'm using this get function which is available in the in the dictionary as I have already shown you.

497
00:24:06,000 --> 00:24:08,000
And I'll go and search for this specific word.

498
00:24:08,000 --> 00:24:09,000
Okay.

499
00:24:09,000 --> 00:24:12,000
Uh, if it is not present then the value will be assigned to zero.

500
00:24:12,000 --> 00:24:14,000
Otherwise we are just going to increment with one.

501
00:24:14,000 --> 00:24:21,000
And we have already seen Dot get in our previous, uh videos when we discussed about dictionaries.

502
00:24:21,000 --> 00:24:24,000
And finally when once it does it, I'm just going to return my word count.

503
00:24:24,000 --> 00:24:29,000
I need it needs to be with respect to this particular width, right in the same line.

504
00:24:29,000 --> 00:24:33,000
Now let me just go ahead and call the function here.

505
00:24:33,000 --> 00:24:36,000
First of all I need to give my file path okay.

506
00:24:36,000 --> 00:24:37,000
File path is very simple.

507
00:24:37,000 --> 00:24:40,000
In the same working location I have sample dot txt file.

508
00:24:40,000 --> 00:24:42,000
So this is the same file.

509
00:24:42,000 --> 00:24:46,000
It is present in my uh same folder location that is functions.

510
00:24:46,000 --> 00:24:49,000
So I'm just going to go ahead and call this.

511
00:24:49,000 --> 00:24:57,000
Then I'm going to use word underscore frequency is equal to count underscore word underscore frequency.

512
00:24:57,000 --> 00:25:01,000
And then I'm just going to give the file path okay.

513
00:25:01,000 --> 00:25:03,000
So this will basically be my file path.

514
00:25:03,000 --> 00:25:09,000
Now after this I will just go ahead and print the word frequency I see each and every thing is done.

515
00:25:09,000 --> 00:25:14,000
Let me execute and always make sure guys the indentation is the main key thing many people may face.

516
00:25:14,000 --> 00:25:20,000
Problem if your indentation is not correct okay, so now if I go ahead and execute it uh cannot access

517
00:25:20,000 --> 00:25:23,000
local variable word where it is not associated with a value.

518
00:25:23,000 --> 00:25:27,000
So uh let's see where is the error.

519
00:25:27,000 --> 00:25:31,000
So what frequency of word uh frequency of file path.

520
00:25:32,000 --> 00:25:37,000
Um, if I'm going inside this particular function inside this, it is going to forwards.

521
00:25:37,000 --> 00:25:38,000
Inward.

522
00:25:38,000 --> 00:25:38,000
Okay.

523
00:25:38,000 --> 00:25:39,000
Uh, okay.

524
00:25:39,000 --> 00:25:40,000
It should be opposite.

525
00:25:40,000 --> 00:25:41,000
Okay.

526
00:25:41,000 --> 00:25:44,000
So I'll just go ahead and write this because I have to access words.

527
00:25:44,000 --> 00:25:46,000
So here you can see hello is present.

528
00:25:46,000 --> 00:25:47,000
One word is present.

529
00:25:47,000 --> 00:25:49,000
Everything is present one okay.

530
00:25:49,000 --> 00:25:52,000
So let me just go ahead and save it and let me write again.

531
00:25:52,000 --> 00:25:54,000
Crush okay.

532
00:25:54,000 --> 00:25:56,000
So crush is present two times.

533
00:25:56,000 --> 00:25:59,000
So if I go ahead and execute I should be getting crush two times.

534
00:25:59,000 --> 00:26:05,000
So here is crush Okay, a simple example of a function to read a file and count the frequency of each

535
00:26:05,000 --> 00:26:05,000
word.

536
00:26:05,000 --> 00:26:09,000
So here we have taken a sample file and we have read it uh in the read mode.

537
00:26:09,000 --> 00:26:11,000
And we have counted each and every word.

538
00:26:11,000 --> 00:26:12,000
Amazing function again.

539
00:26:12,000 --> 00:26:15,000
And I hope you are learning many things out of it.

540
00:26:15,000 --> 00:26:18,000
Okay, more about the file operations we will be discussing.

541
00:26:18,000 --> 00:26:22,000
There is a separate section that will be coming up as we go ahead.

542
00:26:23,000 --> 00:26:24,000
Now.

543
00:26:24,000 --> 00:26:25,000
final task.

544
00:26:25,000 --> 00:26:26,000
This is for you.

545
00:26:27,000 --> 00:26:29,000
Um, anyhow, I'll be giving you the code.

546
00:26:29,000 --> 00:26:32,000
Okay, so here the question is very simple.

547
00:26:32,000 --> 00:26:34,000
You need to validate the email address.

548
00:26:34,000 --> 00:26:35,000
Okay.

549
00:26:35,000 --> 00:26:41,000
So let's say that you are there is a subscription uh, emails that you really want to get from a company.

550
00:26:41,000 --> 00:26:46,000
Let's say there is a page and people will go ahead and write any email and just click on start subscription,

551
00:26:46,000 --> 00:26:49,000
right if they want the free materials or anything as such.

552
00:26:49,000 --> 00:26:53,000
Uh, now the problem is that someone may not put a valid email address.

553
00:26:53,000 --> 00:26:56,000
So we also need to do the valid email check.

554
00:26:56,000 --> 00:27:00,000
So for this I will already give you this particular code okay.

555
00:27:00,000 --> 00:27:06,000
And you can go ahead and try it out and just try to understand it here I've used every special characters

556
00:27:06,000 --> 00:27:06,000
okay.

557
00:27:06,000 --> 00:27:09,000
It should it should be matching this pattern.

558
00:27:09,000 --> 00:27:09,000
Right.

559
00:27:09,000 --> 00:27:16,000
Like let's say one of my email address is some username at the rate it can be gmail.com.

560
00:27:16,000 --> 00:27:16,000
Right.

561
00:27:16,000 --> 00:27:19,000
So similarly this is my first regular expression right.

562
00:27:19,000 --> 00:27:26,000
It can be between A to Z capital E to z 0 to 9 plus uh then again add the rate will be there.

563
00:27:26,000 --> 00:27:27,000
Again you can have Gmail.

564
00:27:27,000 --> 00:27:28,000
You can have Hotmail.

565
00:27:28,000 --> 00:27:30,000
You can have Yahoo anything as such.

566
00:27:30,000 --> 00:27:32,000
And then finally.com.

567
00:27:32,000 --> 00:27:32,000
Right.

568
00:27:32,000 --> 00:27:38,000
So this will be the entire, uh, matching uh for the regular expression I will talk more about.

569
00:27:38,000 --> 00:27:40,000
Regular expression, uh, as I go ahead.

570
00:27:40,000 --> 00:27:44,000
Now, if I go ahead and check this, you will be able to see it here.

571
00:27:44,000 --> 00:27:46,000
You can see this is my true email.

572
00:27:46,000 --> 00:27:47,000
Um, this is a valid email.

573
00:27:47,000 --> 00:27:48,000
This is not a valid email.

574
00:27:48,000 --> 00:27:50,000
So just go through this and check it out.

575
00:27:50,000 --> 00:27:55,000
Uh, the reason why I'm including some new, new things so that you get excited by just seeing all this

576
00:27:55,000 --> 00:27:56,000
kind of application.

577
00:27:56,000 --> 00:27:59,000
So I hope, uh, you like this particular video.

578
00:27:59,000 --> 00:28:01,000
Uh, this was it from my side.

579
00:28:01,000 --> 00:28:02,000
I will see you on the next video.

580
00:28:02,000 --> 00:28:03,000
Thank you.

