)\n",
317 | "print(df.shape)\n",
318 | "```"
319 | ]
320 | },
321 | {
322 | "cell_type": "markdown",
323 | "metadata": {},
324 | "source": [
325 | "***\n",
326 | "# Tables\n",
327 | "***"
328 | ]
329 | },
330 | {
331 | "cell_type": "markdown",
332 | "metadata": {},
333 | "source": [
334 | "use your styling capabilties :)\n",
335 | "\n",
336 | "|COLUMN1|COLUMN2|COLUMN3|\n",
337 | "|-------|-------|-------|\n",
338 | "|x |y |z |\n",
339 | "| VAL | OK | What! |\n",
340 | "| 1 | 2 | 7 |"
341 | ]
342 | },
343 | {
344 | "cell_type": "markdown",
345 | "metadata": {},
346 | "source": [
347 | "### Centering table \n",
348 | "for centered Use :-:
\n",
349 | "for left centered use — or :-
\n",
350 | "for right centered use -:
\n",
351 | "\n",
352 | "\n",
353 | "|COLUMN1|COLUMN2|COLUMN3|\n",
354 | "| :---: | :---: | :---: |\n",
355 | "|x |y |z |\n",
356 | "| VAL | OK | What! |\n",
357 | "| 1 | 2 | 7 |\n",
358 | "\n",
359 | "|COLUMN1|COLUMN2|COLUMN3|\n",
360 | "| :--- | :--- | :--- |\n",
361 | "|x |y |z |\n",
362 | "| VAL | OK | What! |\n",
363 | "| 1 | 2 | 7 |\n",
364 | "\n",
365 | "|COLUMN1|COLUMN2|COLUMN3|\n",
366 | "| ---: | ---: | ---: |\n",
367 | "|x |y |z |\n",
368 | "| VAL | OK | What! |\n",
369 | "| 1 | 2 | 7 |"
370 | ]
371 | },
372 | {
373 | "cell_type": "markdown",
374 | "metadata": {},
375 | "source": [
376 | "***\n",
377 | "# Image!!\n",
378 | "***"
379 | ]
380 | },
381 | {
382 | "cell_type": "markdown",
383 | "metadata": {},
384 | "source": [
385 | ""
386 | ]
387 | },
388 | {
389 | "cell_type": "markdown",
390 | "metadata": {},
391 | "source": [
392 | ""
393 | ]
394 | },
395 | {
396 | "cell_type": "markdown",
397 | "metadata": {},
398 | "source": [
399 | "***\n",
400 | "# HTML tricks\n",
401 | "***"
402 | ]
403 | },
404 | {
405 | "cell_type": "markdown",
406 | "metadata": {},
407 | "source": [
408 | "### Text coloring\n",
409 | "\n",
410 | "The next text is **red** using html tags\n",
411 | "\n",
412 | "or blue \n",
413 | "\n",
414 | "or ***green*** \n",
415 | "\n",
416 | "or ***pink*** \n",
417 | "\n",
418 | "or ***yellow*** \n",
419 | "\n"
420 | ]
421 | },
422 | {
423 | "cell_type": "markdown",
424 | "metadata": {},
425 | "source": [
426 | "### Text font family\n",
427 | "\n",
428 | "Changing font family ***I'M learning newww thingggssssss*** \n",
429 | "\n"
430 | ]
431 | },
432 | {
433 | "cell_type": "markdown",
434 | "metadata": {},
435 | "source": [
436 | "***\n",
437 | "# Cell styling\n",
438 | "***"
439 | ]
440 | },
441 | {
442 | "cell_type": "markdown",
443 | "metadata": {},
444 | "source": [
445 | "Highlight this TEXT with blue background color and white text color\n",
446 | "\n",
447 | "Highlight this **text** with red background color and white text color\n",
448 | "\n",
449 | "Highlight this *TEXT* with black background color and yellow text color
and nice font family text\n"
450 | ]
451 | },
452 | {
453 | "cell_type": "markdown",
454 | "metadata": {},
455 | "source": [
456 | "### Alert boxes"
457 | ]
458 | },
459 | {
460 | "cell_type": "markdown",
461 | "metadata": {},
462 | "source": [
463 | "### Success --> Green\n",
464 | "\n",
465 | "\n",
466 | "Green box means success/good things will happen/happened/happens\n",
467 | "
\n"
468 | ]
469 | },
470 | {
471 | "cell_type": "markdown",
472 | "metadata": {},
473 | "source": [
474 | "### Fail/Error/Danger --> Red\n",
475 | "\n",
476 | "\n",
477 | "Red box means something failed :( or DANGER!!! or Error \n",
478 | "
"
479 | ]
480 | },
481 | {
482 | "cell_type": "markdown",
483 | "metadata": {},
484 | "source": [
485 | "### Warning/Note --> Yellow\n",
486 | "\n",
487 | "\n",
488 | "Please note! or check this warning\n",
489 | "
"
490 | ]
491 | },
492 | {
493 | "cell_type": "markdown",
494 | "metadata": {},
495 | "source": [
496 | "### information/calm down --> blue\n",
497 | "\n",
498 | "\n",
499 | "This color is nice to calm down or for information\n",
500 | "
"
501 | ]
502 | }
503 | ],
504 | "metadata": {
505 | "kernelspec": {
506 | "display_name": "Python 3",
507 | "language": "python",
508 | "name": "python3"
509 | },
510 | "language_info": {
511 | "codemirror_mode": {
512 | "name": "ipython",
513 | "version": 3
514 | },
515 | "file_extension": ".py",
516 | "mimetype": "text/x-python",
517 | "name": "python",
518 | "nbconvert_exporter": "python",
519 | "pygments_lexer": "ipython3",
520 | "version": "3.8.3"
521 | }
522 | },
523 | "nbformat": 4,
524 | "nbformat_minor": 4
525 | }
526 |
--------------------------------------------------------------------------------
/math/math_example.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "id": "amended-enforcement",
7 | "metadata": {},
8 | "outputs": [],
9 | "source": [
10 | "import math"
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "id": "talented-representative",
16 | "metadata": {},
17 | "source": [
18 | "# Mathematical constants"
19 | ]
20 | },
21 | {
22 | "cell_type": "code",
23 | "execution_count": 3,
24 | "id": "removed-washer",
25 | "metadata": {},
26 | "outputs": [
27 | {
28 | "name": "stdout",
29 | "output_type": "stream",
30 | "text": [
31 | "Pi: 3.141592653589793\n",
32 | "E: 2.718281828459045\n",
33 | "Inf: inf\n",
34 | "Tau: 6.283185307179586\n",
35 | "NAN: nan\n"
36 | ]
37 | }
38 | ],
39 | "source": [
40 | "print('Pi:', math.pi)\n",
41 | "print('E:', math.e)\n",
42 | "print('Inf:', math.inf)\n",
43 | "print('Tau:', math.tau)\n",
44 | "print('NAN:', math.nan)"
45 | ]
46 | },
47 | {
48 | "cell_type": "markdown",
49 | "id": "quiet-whale",
50 | "metadata": {},
51 | "source": [
52 | "# Mathematical tasks"
53 | ]
54 | },
55 | {
56 | "cell_type": "code",
57 | "execution_count": 5,
58 | "id": "charming-uncle",
59 | "metadata": {},
60 | "outputs": [
61 | {
62 | "name": "stdout",
63 | "output_type": "stream",
64 | "text": [
65 | "Abs: 5678.0\n",
66 | "SQRT: 5.0\n",
67 | "Pow: 100.0\n",
68 | "Ceil: 10\n",
69 | "Floor: 9\n"
70 | ]
71 | }
72 | ],
73 | "source": [
74 | "print('Abs:', math.fabs(-5678))\n",
75 | "print('SQRT:', math.sqrt(25))\n",
76 | "print('Pow:', math.pow(10, 2))\n",
77 | "print('Ceil:', math.ceil(9.123))\n",
78 | "print('Floor:', math.floor(9.123))"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": 6,
84 | "id": "major-worse",
85 | "metadata": {},
86 | "outputs": [
87 | {
88 | "name": "stdout",
89 | "output_type": "stream",
90 | "text": [
91 | "Sin: 0.0\n",
92 | "Cos: 1.0\n",
93 | "Tan: 0.0\n"
94 | ]
95 | }
96 | ],
97 | "source": [
98 | "print('Sin:', math.sin(0))\n",
99 | "print('Cos:', math.cos(0))\n",
100 | "print('Tan:', math.tan(0))"
101 | ]
102 | },
103 | {
104 | "cell_type": "code",
105 | "execution_count": 7,
106 | "id": "elect-updating",
107 | "metadata": {},
108 | "outputs": [
109 | {
110 | "name": "stdout",
111 | "output_type": "stream",
112 | "text": [
113 | "Logarithm: 4.605170185988092\n",
114 | "Logarithm2: 6.643856189774724\n",
115 | "Logarithm10: 2.0\n",
116 | "Exp: 148.4131591025766\n",
117 | "Factorial: 24\n"
118 | ]
119 | }
120 | ],
121 | "source": [
122 | "print('Logarithm:', math.log(100))\n",
123 | "print('Logarithm2:', math.log2(100))\n",
124 | "print('Logarithm10:', math.log10(100))\n",
125 | "print('Exp:', math.exp(5))\n",
126 | "print('Factorial:', math.factorial(4))"
127 | ]
128 | },
129 | {
130 | "cell_type": "code",
131 | "execution_count": 8,
132 | "id": "neutral-oxygen",
133 | "metadata": {},
134 | "outputs": [
135 | {
136 | "name": "stdout",
137 | "output_type": "stream",
138 | "text": [
139 | "Help on built-in module math:\n",
140 | "\n",
141 | "NAME\n",
142 | " math\n",
143 | "\n",
144 | "DESCRIPTION\n",
145 | " This module provides access to the mathematical functions\n",
146 | " defined by the C standard.\n",
147 | "\n",
148 | "FUNCTIONS\n",
149 | " acos(x, /)\n",
150 | " Return the arc cosine (measured in radians) of x.\n",
151 | " \n",
152 | " acosh(x, /)\n",
153 | " Return the inverse hyperbolic cosine of x.\n",
154 | " \n",
155 | " asin(x, /)\n",
156 | " Return the arc sine (measured in radians) of x.\n",
157 | " \n",
158 | " asinh(x, /)\n",
159 | " Return the inverse hyperbolic sine of x.\n",
160 | " \n",
161 | " atan(x, /)\n",
162 | " Return the arc tangent (measured in radians) of x.\n",
163 | " \n",
164 | " atan2(y, x, /)\n",
165 | " Return the arc tangent (measured in radians) of y/x.\n",
166 | " \n",
167 | " Unlike atan(y/x), the signs of both x and y are considered.\n",
168 | " \n",
169 | " atanh(x, /)\n",
170 | " Return the inverse hyperbolic tangent of x.\n",
171 | " \n",
172 | " ceil(x, /)\n",
173 | " Return the ceiling of x as an Integral.\n",
174 | " \n",
175 | " This is the smallest integer >= x.\n",
176 | " \n",
177 | " comb(n, k, /)\n",
178 | " Number of ways to choose k items from n items without repetition and without order.\n",
179 | " \n",
180 | " Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n",
181 | " to zero when k > n.\n",
182 | " \n",
183 | " Also called the binomial coefficient because it is equivalent\n",
184 | " to the coefficient of k-th term in polynomial expansion of the\n",
185 | " expression (1 + x)**n.\n",
186 | " \n",
187 | " Raises TypeError if either of the arguments are not integers.\n",
188 | " Raises ValueError if either of the arguments are negative.\n",
189 | " \n",
190 | " copysign(x, y, /)\n",
191 | " Return a float with the magnitude (absolute value) of x but the sign of y.\n",
192 | " \n",
193 | " On platforms that support signed zeros, copysign(1.0, -0.0)\n",
194 | " returns -1.0.\n",
195 | " \n",
196 | " cos(x, /)\n",
197 | " Return the cosine of x (measured in radians).\n",
198 | " \n",
199 | " cosh(x, /)\n",
200 | " Return the hyperbolic cosine of x.\n",
201 | " \n",
202 | " degrees(x, /)\n",
203 | " Convert angle x from radians to degrees.\n",
204 | " \n",
205 | " dist(p, q, /)\n",
206 | " Return the Euclidean distance between two points p and q.\n",
207 | " \n",
208 | " The points should be specified as sequences (or iterables) of\n",
209 | " coordinates. Both inputs must have the same dimension.\n",
210 | " \n",
211 | " Roughly equivalent to:\n",
212 | " sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))\n",
213 | " \n",
214 | " erf(x, /)\n",
215 | " Error function at x.\n",
216 | " \n",
217 | " erfc(x, /)\n",
218 | " Complementary error function at x.\n",
219 | " \n",
220 | " exp(x, /)\n",
221 | " Return e raised to the power of x.\n",
222 | " \n",
223 | " expm1(x, /)\n",
224 | " Return exp(x)-1.\n",
225 | " \n",
226 | " This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
227 | " \n",
228 | " fabs(x, /)\n",
229 | " Return the absolute value of the float x.\n",
230 | " \n",
231 | " factorial(x, /)\n",
232 | " Find x!.\n",
233 | " \n",
234 | " Raise a ValueError if x is negative or non-integral.\n",
235 | " \n",
236 | " floor(x, /)\n",
237 | " Return the floor of x as an Integral.\n",
238 | " \n",
239 | " This is the largest integer <= x.\n",
240 | " \n",
241 | " fmod(x, y, /)\n",
242 | " Return fmod(x, y), according to platform C.\n",
243 | " \n",
244 | " x % y may differ.\n",
245 | " \n",
246 | " frexp(x, /)\n",
247 | " Return the mantissa and exponent of x, as pair (m, e).\n",
248 | " \n",
249 | " m is a float and e is an int, such that x = m * 2.**e.\n",
250 | " If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.\n",
251 | " \n",
252 | " fsum(seq, /)\n",
253 | " Return an accurate floating point sum of values in the iterable seq.\n",
254 | " \n",
255 | " Assumes IEEE-754 floating point arithmetic.\n",
256 | " \n",
257 | " gamma(x, /)\n",
258 | " Gamma function at x.\n",
259 | " \n",
260 | " gcd(x, y, /)\n",
261 | " greatest common divisor of x and y\n",
262 | " \n",
263 | " hypot(...)\n",
264 | " hypot(*coordinates) -> value\n",
265 | " \n",
266 | " Multidimensional Euclidean distance from the origin to a point.\n",
267 | " \n",
268 | " Roughly equivalent to:\n",
269 | " sqrt(sum(x**2 for x in coordinates))\n",
270 | " \n",
271 | " For a two dimensional point (x, y), gives the hypotenuse\n",
272 | " using the Pythagorean theorem: sqrt(x*x + y*y).\n",
273 | " \n",
274 | " For example, the hypotenuse of a 3/4/5 right triangle is:\n",
275 | " \n",
276 | " >>> hypot(3.0, 4.0)\n",
277 | " 5.0\n",
278 | " \n",
279 | " isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
280 | " Determine whether two floating point numbers are close in value.\n",
281 | " \n",
282 | " rel_tol\n",
283 | " maximum difference for being considered \"close\", relative to the\n",
284 | " magnitude of the input values\n",
285 | " abs_tol\n",
286 | " maximum difference for being considered \"close\", regardless of the\n",
287 | " magnitude of the input values\n",
288 | " \n",
289 | " Return True if a is close in value to b, and False otherwise.\n",
290 | " \n",
291 | " For the values to be considered close, the difference between them\n",
292 | " must be smaller than at least one of the tolerances.\n",
293 | " \n",
294 | " -inf, inf and NaN behave similarly to the IEEE 754 Standard. That\n",
295 | " is, NaN is not close to anything, even itself. inf and -inf are\n",
296 | " only close to themselves.\n",
297 | " \n",
298 | " isfinite(x, /)\n",
299 | " Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
300 | " \n",
301 | " isinf(x, /)\n",
302 | " Return True if x is a positive or negative infinity, and False otherwise.\n",
303 | " \n",
304 | " isnan(x, /)\n",
305 | " Return True if x is a NaN (not a number), and False otherwise.\n",
306 | " \n",
307 | " isqrt(n, /)\n",
308 | " Return the integer part of the square root of the input.\n",
309 | " \n",
310 | " ldexp(x, i, /)\n",
311 | " Return x * (2**i).\n",
312 | " \n",
313 | " This is essentially the inverse of frexp().\n",
314 | " \n",
315 | " lgamma(x, /)\n",
316 | " Natural logarithm of absolute value of Gamma function at x.\n",
317 | " \n",
318 | " log(...)\n",
319 | " log(x, [base=math.e])\n",
320 | " Return the logarithm of x to the given base.\n",
321 | " \n",
322 | " If the base not specified, returns the natural logarithm (base e) of x.\n",
323 | " \n",
324 | " log10(x, /)\n",
325 | " Return the base 10 logarithm of x.\n",
326 | " \n",
327 | " log1p(x, /)\n",
328 | " Return the natural logarithm of 1+x (base e).\n",
329 | " \n",
330 | " The result is computed in a way which is accurate for x near zero.\n",
331 | " \n",
332 | " log2(x, /)\n",
333 | " Return the base 2 logarithm of x.\n",
334 | " \n",
335 | " modf(x, /)\n",
336 | " Return the fractional and integer parts of x.\n",
337 | " \n",
338 | " Both results carry the sign of x and are floats.\n",
339 | " \n",
340 | " perm(n, k=None, /)\n",
341 | " Number of ways to choose k items from n items without repetition and with order.\n",
342 | " \n",
343 | " Evaluates to n! / (n - k)! when k <= n and evaluates\n",
344 | " to zero when k > n.\n",
345 | " \n",
346 | " If k is not specified or is None, then k defaults to n\n",
347 | " and the function returns n!.\n",
348 | " \n",
349 | " Raises TypeError if either of the arguments are not integers.\n",
350 | " Raises ValueError if either of the arguments are negative.\n",
351 | " \n",
352 | " pow(x, y, /)\n",
353 | " Return x**y (x to the power of y).\n",
354 | " \n",
355 | " prod(iterable, /, *, start=1)\n",
356 | " Calculate the product of all the elements in the input iterable.\n",
357 | " \n",
358 | " The default start value for the product is 1.\n",
359 | " \n",
360 | " When the iterable is empty, return the start value. This function is\n",
361 | " intended specifically for use with numeric values and may reject\n",
362 | " non-numeric types.\n",
363 | " \n",
364 | " radians(x, /)\n",
365 | " Convert angle x from degrees to radians.\n",
366 | " \n",
367 | " remainder(x, y, /)\n",
368 | " Difference between x and the closest integer multiple of y.\n",
369 | " \n",
370 | " Return x - n*y where n*y is the closest integer multiple of y.\n",
371 | " In the case where x is exactly halfway between two multiples of\n",
372 | " y, the nearest even value of n is used. The result is always exact.\n",
373 | " \n",
374 | " sin(x, /)\n",
375 | " Return the sine of x (measured in radians).\n",
376 | " \n",
377 | " sinh(x, /)\n",
378 | " Return the hyperbolic sine of x.\n",
379 | " \n",
380 | " sqrt(x, /)\n",
381 | " Return the square root of x.\n",
382 | " \n",
383 | " tan(x, /)\n",
384 | " Return the tangent of x (measured in radians).\n",
385 | " \n",
386 | " tanh(x, /)\n",
387 | " Return the hyperbolic tangent of x.\n",
388 | " \n",
389 | " trunc(x, /)\n",
390 | " Truncates the Real x to the nearest Integral toward 0.\n",
391 | " \n",
392 | " Uses the __trunc__ magic method.\n",
393 | "\n",
394 | "DATA\n",
395 | " e = 2.718281828459045\n",
396 | " inf = inf\n",
397 | " nan = nan\n",
398 | " pi = 3.141592653589793\n",
399 | " tau = 6.283185307179586\n",
400 | "\n",
401 | "FILE\n",
402 | " (built-in)\n",
403 | "\n",
404 | "\n"
405 | ]
406 | }
407 | ],
408 | "source": [
409 | "help(math)"
410 | ]
411 | }
412 | ],
413 | "metadata": {
414 | "kernelspec": {
415 | "display_name": "Python 3",
416 | "language": "python",
417 | "name": "python3"
418 | },
419 | "language_info": {
420 | "codemirror_mode": {
421 | "name": "ipython",
422 | "version": 3
423 | },
424 | "file_extension": ".py",
425 | "mimetype": "text/x-python",
426 | "name": "python",
427 | "nbconvert_exporter": "python",
428 | "pygments_lexer": "ipython3",
429 | "version": "3.8.3"
430 | }
431 | },
432 | "nbformat": 4,
433 | "nbformat_minor": 5
434 | }
435 |
--------------------------------------------------------------------------------
/re_library/re_library.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "id": "velvet-terry",
6 | "metadata": {},
7 | "source": [
8 | "# Regular Expressions - re library"
9 | ]
10 | },
11 | {
12 | "cell_type": "code",
13 | "execution_count": 1,
14 | "id": "neutral-dover",
15 | "metadata": {},
16 | "outputs": [],
17 | "source": [
18 | "import re"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "id": "lasting-withdrawal",
24 | "metadata": {},
25 | "source": [
26 | "## re useful functions\n",
27 | "\n",
28 | "* findall ==> Returns a list containing all matches\n",
29 | "* search ==> Returns a *Match object* if there is a match anywhere in the string\n",
30 | " * Match object - homework :)\n",
31 | "* split ==> Returns a list where the string has been split at each match\n",
32 | "* match ==> Returns a *Match object* if there is a match, otherwise None object"
33 | ]
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "id": "golden-sheep",
38 | "metadata": {},
39 | "source": [
40 | "## Simple and Basic pattern\n",
41 | "\n",
42 | "### Ordinary characters"
43 | ]
44 | },
45 | {
46 | "cell_type": "code",
47 | "execution_count": null,
48 | "id": "international-terminology",
49 | "metadata": {},
50 | "outputs": [],
51 | "source": [
52 | "txt = 'Saeed'\n",
53 | "pattern = 'Saeed'\n",
54 | "if re.match(pattern, txt):\n",
55 | " print('Yes!!! match')\n",
56 | "else:\n",
57 | " print('Noo!!! does not match')"
58 | ]
59 | },
60 | {
61 | "cell_type": "markdown",
62 | "id": "mighty-behalf",
63 | "metadata": {},
64 | "source": [
65 | "## Special Characters"
66 | ]
67 | },
68 | {
69 | "cell_type": "markdown",
70 | "id": "verified-pipeline",
71 | "metadata": {},
72 | "source": [
73 | "## . \n",
74 | "##### A period, Matches **any single** character except the newline character"
75 | ]
76 | },
77 | {
78 | "cell_type": "code",
79 | "execution_count": null,
80 | "id": "stone-zambia",
81 | "metadata": {},
82 | "outputs": [],
83 | "source": [
84 | "txt = \"Saeed\"\n",
85 | "pattern = \"S.e.d\"\n",
86 | "m = re.findall(pattern, txt)\n",
87 | "print(m)"
88 | ]
89 | },
90 | {
91 | "cell_type": "markdown",
92 | "id": "smart-firewall",
93 | "metadata": {},
94 | "source": [
95 | "***\n",
96 | "## ^ \n",
97 | "##### A caret, Matches the **start** of the string."
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": null,
103 | "id": "serial-mention",
104 | "metadata": {},
105 | "outputs": [],
106 | "source": [
107 | "txt = \"Saeed loves programming\"\n",
108 | "pattern = \"^Saeed\"\n",
109 | "m = re.findall(pattern, txt)\n",
110 | "print(m)"
111 | ]
112 | },
113 | {
114 | "cell_type": "code",
115 | "execution_count": null,
116 | "id": "metallic-antique",
117 | "metadata": {},
118 | "outputs": [],
119 | "source": [
120 | "# Won't work\n",
121 | "txt = \"Saeed loves programming\"\n",
122 | "pattern = \"^loves\" \n",
123 | "m = re.findall(pattern, txt)\n",
124 | "print(m)"
125 | ]
126 | },
127 | {
128 | "cell_type": "markdown",
129 | "id": "amazing-pressing",
130 | "metadata": {},
131 | "source": [
132 | "***\n",
133 | "## $ \n",
134 | "##### Matches the end of string"
135 | ]
136 | },
137 | {
138 | "cell_type": "code",
139 | "execution_count": null,
140 | "id": "mental-surprise",
141 | "metadata": {},
142 | "outputs": [],
143 | "source": [
144 | "txt = \"Saeed loves programming\"\n",
145 | "pattern = \"programming$\" \n",
146 | "m = re.findall(pattern, txt)\n",
147 | "print(m)"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": null,
153 | "id": "innovative-cambodia",
154 | "metadata": {},
155 | "outputs": [],
156 | "source": [
157 | "txt = \"Saeed loves programming\"\n",
158 | "pattern = \"ing$\"\n",
159 | "m = re.findall(pattern, txt)\n",
160 | "print(m)"
161 | ]
162 | },
163 | {
164 | "cell_type": "code",
165 | "execution_count": null,
166 | "id": "turned-moscow",
167 | "metadata": {},
168 | "outputs": [],
169 | "source": [
170 | "txt = \"Saeed loves programming\"\n",
171 | "pattern = \"Saeed$\" \n",
172 | "m = re.findall(pattern, txt)\n",
173 | "print(m)"
174 | ]
175 | },
176 | {
177 | "cell_type": "markdown",
178 | "id": "smoking-monroe",
179 | "metadata": {},
180 | "source": [
181 | "***\n",
182 | "## [19bG] \n",
183 | "##### Matches 1 or 9 or b or G\n",
184 | "## [a-zA-Z0-9]\n",
185 | "##### Matches any letter from (a to z) or (A to Z) or (0 to 9)."
186 | ]
187 | },
188 | {
189 | "cell_type": "code",
190 | "execution_count": null,
191 | "id": "packed-eating",
192 | "metadata": {},
193 | "outputs": [],
194 | "source": [
195 | "txt = \"Saeed is 30 years old\"\n",
196 | "pattern = \"[S3of]\" \n",
197 | "m = re.findall(pattern, txt)\n",
198 | "print(m)"
199 | ]
200 | },
201 | {
202 | "cell_type": "code",
203 | "execution_count": null,
204 | "id": "nervous-railway",
205 | "metadata": {},
206 | "outputs": [],
207 | "source": [
208 | "txt = \"Saeed is 30 years old\"\n",
209 | "pattern = \"[1-9]\" \n",
210 | "m = re.findall(pattern, txt)\n",
211 | "print(m)"
212 | ]
213 | },
214 | {
215 | "cell_type": "code",
216 | "execution_count": null,
217 | "id": "failing-municipality",
218 | "metadata": {},
219 | "outputs": [],
220 | "source": [
221 | "txt = \"Saeed is 30 years old\"\n",
222 | "pattern = \"[a-f0-4A-T]aeed\" \n",
223 | "m = re.findall(pattern, txt)\n",
224 | "print(m)"
225 | ]
226 | },
227 | {
228 | "cell_type": "markdown",
229 | "id": "average-snapshot",
230 | "metadata": {},
231 | "source": [
232 | "## using caret ^ in [ ] will look for complementary set"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "execution_count": null,
238 | "id": "cellular-bankruptcy",
239 | "metadata": {},
240 | "outputs": [],
241 | "source": [
242 | "txt = \"4 years\"\n",
243 | "pattern = \"[^9] years\" \n",
244 | "m = re.findall(pattern, txt)\n",
245 | "print(m)"
246 | ]
247 | },
248 | {
249 | "cell_type": "code",
250 | "execution_count": null,
251 | "id": "polyphonic-battlefield",
252 | "metadata": {},
253 | "outputs": [],
254 | "source": [
255 | "txt = \"4 years\"\n",
256 | "pattern = \"[^4] years\" \n",
257 | "m = re.findall(pattern, txt)\n",
258 | "print(m)"
259 | ]
260 | },
261 | {
262 | "cell_type": "markdown",
263 | "id": "comic-large",
264 | "metadata": {},
265 | "source": [
266 | "***\n",
267 | "## \\ \n",
268 | "##### Backslash - 2 options\n",
269 | "* Option1: special characters, such as (\\t, \\s, ...)\n",
270 | "* Option2: not special character, treated like any other character or removes special meaning (\\\\\\s, \\\\\\t, ...)"
271 | ]
272 | },
273 | {
274 | "cell_type": "code",
275 | "execution_count": null,
276 | "id": "central-witness",
277 | "metadata": {},
278 | "outputs": [],
279 | "source": [
280 | "# Option 1 - treating \\ with special charachter (\\s mean space)\n",
281 | "txt = \"Subscribe saeed channel\"\n",
282 | "pattern = \"Subscribe\\saeed\" \n",
283 | "m = re.findall(pattern, txt)\n",
284 | "print(m)\n"
285 | ]
286 | },
287 | {
288 | "cell_type": "code",
289 | "execution_count": null,
290 | "id": "super-costs",
291 | "metadata": {},
292 | "outputs": [],
293 | "source": [
294 | "txt = \"Subscribe saeed channel\"\n",
295 | "pattern = \"Subscribe\\ssaeed\" \n",
296 | "m = re.findall(pattern, txt)\n",
297 | "print(m)"
298 | ]
299 | },
300 | {
301 | "cell_type": "code",
302 | "execution_count": null,
303 | "id": "inside-investigator",
304 | "metadata": {},
305 | "outputs": [],
306 | "source": [
307 | "# Option 2 - treating \\ like any other character\n",
308 | "txt = \"Subscribe [s]aeed channel\"\n",
309 | "pattern = \"Subscribe \\[s\\]aeed\"\n",
310 | "m = re.findall(pattern, txt)\n",
311 | "print(m)"
312 | ]
313 | },
314 | {
315 | "cell_type": "markdown",
316 | "id": "composite-debate",
317 | "metadata": {},
318 | "source": [
319 | "***\n",
320 | "## more special characters\n",
321 | "* \\t - Matches tab\n",
322 | "* \\n - Matches newline\n",
323 | "* \\A - Matches only at the start of the string\n",
324 | "* \\Z - Matches only at the end of the string\n"
325 | ]
326 | },
327 | {
328 | "cell_type": "code",
329 | "execution_count": null,
330 | "id": "unauthorized-grave",
331 | "metadata": {},
332 | "outputs": [],
333 | "source": [
334 | "# reminder ^ sign \n",
335 | "txt = \"Saeed loves programming\"\n",
336 | "pattern = \"\\ASaeed\" \n",
337 | "m = re.findall(pattern, txt)\n",
338 | "print(m)"
339 | ]
340 | },
341 | {
342 | "cell_type": "code",
343 | "execution_count": null,
344 | "id": "median-arlington",
345 | "metadata": {},
346 | "outputs": [],
347 | "source": [
348 | "# reminder $ sign\n",
349 | "txt = \"Saeed loves programming\"\n",
350 | "pattern = \"ming\\Z\" \n",
351 | "m = re.findall(pattern, txt)\n",
352 | "print(m)"
353 | ]
354 | },
355 | {
356 | "cell_type": "markdown",
357 | "id": "architectural-county",
358 | "metadata": {},
359 | "source": [
360 | "***\n",
361 | "## Next video\n",
362 | "* \\w, \\W, \\s, \\S, \\d, \\D, \n",
363 | "* Repetions: *, + , ?, {}\n",
364 | "* Examples\n",
365 | "***"
366 | ]
367 | },
368 | {
369 | "cell_type": "markdown",
370 | "id": "light-tuner",
371 | "metadata": {},
372 | "source": [
373 | "***\n",
374 | "## \\w & \\W\n",
375 | "##### \\w: Matches any single letter, digit, or underscore\n",
376 | "##### \\W: Matches any character not part of \\w (complementary set)"
377 | ]
378 | },
379 | {
380 | "cell_type": "code",
381 | "execution_count": 2,
382 | "id": "alone-rhythm",
383 | "metadata": {},
384 | "outputs": [
385 | {
386 | "name": "stdout",
387 | "output_type": "stream",
388 | "text": [
389 | "['Saeed loves programming']\n"
390 | ]
391 | }
392 | ],
393 | "source": [
394 | "txt = \"Saeed loves programming\"\n",
395 | "pattern = \"Saeed loves \\wrogramming\" \n",
396 | "# similar to [0-9a-zA-Z_]\n",
397 | "m = re.findall(pattern, txt)\n",
398 | "print(m)"
399 | ]
400 | },
401 | {
402 | "cell_type": "code",
403 | "execution_count": 3,
404 | "id": "southeast-crowd",
405 | "metadata": {},
406 | "outputs": [
407 | {
408 | "name": "stdout",
409 | "output_type": "stream",
410 | "text": [
411 | "['Saeed loves %rogramming']\n"
412 | ]
413 | }
414 | ],
415 | "source": [
416 | "txt = \"Saeed loves %rogramming\"\n",
417 | "pattern = \"Saeed loves \\Wrogramming\" \n",
418 | "# similar to [^0-9a-zA-Z_]\n",
419 | "m = re.findall(pattern, txt)\n",
420 | "print(m)"
421 | ]
422 | },
423 | {
424 | "cell_type": "markdown",
425 | "id": "scenic-mountain",
426 | "metadata": {},
427 | "source": [
428 | "***\n",
429 | "## \\d & \\D\n",
430 | "##### \\d: Matches decimal digit 0-9\n",
431 | "##### \\D: Matches any character that is not a digit (complementary set)"
432 | ]
433 | },
434 | {
435 | "cell_type": "code",
436 | "execution_count": 4,
437 | "id": "balanced-spank",
438 | "metadata": {},
439 | "outputs": [
440 | {
441 | "name": "stdout",
442 | "output_type": "stream",
443 | "text": [
444 | "['4 years']\n"
445 | ]
446 | }
447 | ],
448 | "source": [
449 | "txt = \"4 years\"\n",
450 | "pattern = r\"\\d years\" \n",
451 | "# similar to [0-9]\n",
452 | "m = re.findall(pattern, txt)\n",
453 | "print(m)"
454 | ]
455 | },
456 | {
457 | "cell_type": "code",
458 | "execution_count": 6,
459 | "id": "julian-equilibrium",
460 | "metadata": {},
461 | "outputs": [
462 | {
463 | "name": "stdout",
464 | "output_type": "stream",
465 | "text": [
466 | "['% years']\n"
467 | ]
468 | }
469 | ],
470 | "source": [
471 | "txt = \"% years\" \n",
472 | "pattern = r\"\\D years\"\n",
473 | "# similar to [^0-9]\n",
474 | "m = re.findall(pattern, txt)\n",
475 | "print(m)"
476 | ]
477 | },
478 | {
479 | "cell_type": "markdown",
480 | "id": "simplified-actor",
481 | "metadata": {},
482 | "source": [
483 | "***\n",
484 | "## \\s & \\S\n",
485 | "##### \\s: Matches a single whitespace character like: space, newline, tab, return\n",
486 | "##### \\S: Matches any character that is not a single whitespace character (complementary set)"
487 | ]
488 | },
489 | {
490 | "cell_type": "code",
491 | "execution_count": 7,
492 | "id": "permanent-badge",
493 | "metadata": {},
494 | "outputs": [
495 | {
496 | "name": "stdout",
497 | "output_type": "stream",
498 | "text": [
499 | "['Saeed loves']\n"
500 | ]
501 | }
502 | ],
503 | "source": [
504 | "txt = \"Saeed loves programming\"\n",
505 | "pattern = \"Saeed\\sloves\" \n",
506 | "m = re.findall(pattern, txt)\n",
507 | "print(m)"
508 | ]
509 | },
510 | {
511 | "cell_type": "code",
512 | "execution_count": 10,
513 | "id": "lucky-directive",
514 | "metadata": {},
515 | "outputs": [
516 | {
517 | "name": "stdout",
518 | "output_type": "stream",
519 | "text": [
520 | "['Saeed9loves']\n"
521 | ]
522 | }
523 | ],
524 | "source": [
525 | "txt = \"Saeed-loves programming\"\n",
526 | "pattern = \"Saeed\\Sloves\" \n",
527 | "m = re.findall(pattern, txt)\n",
528 | "print(m)"
529 | ]
530 | },
531 | {
532 | "cell_type": "markdown",
533 | "id": "offshore-seeker",
534 | "metadata": {},
535 | "source": [
536 | "## Repeitions"
537 | ]
538 | },
539 | {
540 | "cell_type": "markdown",
541 | "id": "spoken-error",
542 | "metadata": {},
543 | "source": [
544 | "## +\n",
545 | "##### Checks if the preceding character appears **one or more** times starting from that position"
546 | ]
547 | },
548 | {
549 | "cell_type": "code",
550 | "execution_count": 11,
551 | "id": "outdoor-phone",
552 | "metadata": {},
553 | "outputs": [
554 | {
555 | "name": "stdout",
556 | "output_type": "stream",
557 | "text": [
558 | "['programmmmmmmming']\n"
559 | ]
560 | }
561 | ],
562 | "source": [
563 | "txt = \"programmmmmmmming\"\n",
564 | "pattern = \"program+ing\" \n",
565 | "m = re.findall(pattern, txt)\n",
566 | "print(m)"
567 | ]
568 | },
569 | {
570 | "cell_type": "code",
571 | "execution_count": 12,
572 | "id": "liquid-rough",
573 | "metadata": {},
574 | "outputs": [
575 | {
576 | "name": "stdout",
577 | "output_type": "stream",
578 | "text": [
579 | "['programmmmmmmming']\n"
580 | ]
581 | }
582 | ],
583 | "source": [
584 | "# will this work ?\n",
585 | "txt = \"programmmmmmmming\"\n",
586 | "pattern = \"progra\\w+ing\"\n",
587 | "m = re.findall(pattern, txt)\n",
588 | "print(m)"
589 | ]
590 | },
591 | {
592 | "cell_type": "code",
593 | "execution_count": 13,
594 | "id": "streaming-aruba",
595 | "metadata": {},
596 | "outputs": [
597 | {
598 | "name": "stdout",
599 | "output_type": "stream",
600 | "text": [
601 | "['programmmmmmmming']\n"
602 | ]
603 | }
604 | ],
605 | "source": [
606 | "# will this work ?\n",
607 | "txt = \"programmmmmmmming\"\n",
608 | "pattern = \"progra[a-z]+ing\" \n",
609 | "m = re.findall(pattern, txt)\n",
610 | "print(m)"
611 | ]
612 | },
613 | {
614 | "cell_type": "code",
615 | "execution_count": 14,
616 | "id": "junior-ensemble",
617 | "metadata": {},
618 | "outputs": [
619 | {
620 | "name": "stdout",
621 | "output_type": "stream",
622 | "text": [
623 | "[]\n"
624 | ]
625 | }
626 | ],
627 | "source": [
628 | "# This will not work!\n",
629 | "txt = \"programmmmmmmming\"\n",
630 | "pattern = \"progras+ing\" \n",
631 | "m = re.findall(pattern, txt)\n",
632 | "print(m)"
633 | ]
634 | },
635 | {
636 | "cell_type": "markdown",
637 | "id": "solved-killing",
638 | "metadata": {},
639 | "source": [
640 | "## *\n",
641 | "##### Checks if the preceding character appears **zero or more** times starting from that position"
642 | ]
643 | },
644 | {
645 | "cell_type": "code",
646 | "execution_count": 15,
647 | "id": "forbidden-grace",
648 | "metadata": {},
649 | "outputs": [
650 | {
651 | "name": "stdout",
652 | "output_type": "stream",
653 | "text": [
654 | "['programmmmmmmming']\n"
655 | ]
656 | }
657 | ],
658 | "source": [
659 | "txt = \"programmmmmmmming\"\n",
660 | "pattern = \"program*ing\" \n",
661 | "m = re.findall(pattern, txt)\n",
662 | "print(m)"
663 | ]
664 | },
665 | {
666 | "cell_type": "code",
667 | "execution_count": 16,
668 | "id": "entitled-night",
669 | "metadata": {},
670 | "outputs": [
671 | {
672 | "name": "stdout",
673 | "output_type": "stream",
674 | "text": [
675 | "['programmmmmmmming']\n"
676 | ]
677 | }
678 | ],
679 | "source": [
680 | "txt = \"programmmmmmmming\"\n",
681 | "pattern = \"program*f*ing\" \n",
682 | "m = re.findall(pattern, txt)\n",
683 | "print(m)"
684 | ]
685 | },
686 | {
687 | "cell_type": "markdown",
688 | "id": "composite-glance",
689 | "metadata": {},
690 | "source": [
691 | "## ?\n",
692 | "##### Checks if the preceding character appears **exactly zero or one** time starting from that position."
693 | ]
694 | },
695 | {
696 | "cell_type": "code",
697 | "execution_count": 17,
698 | "id": "broadband-audience",
699 | "metadata": {},
700 | "outputs": [
701 | {
702 | "name": "stdout",
703 | "output_type": "stream",
704 | "text": [
705 | "['programming']\n"
706 | ]
707 | }
708 | ],
709 | "source": [
710 | "txt = \"programming\"\n",
711 | "pattern = \"programm?ing\" \n",
712 | "m = re.findall(pattern, txt)\n",
713 | "print(m)"
714 | ]
715 | },
716 | {
717 | "cell_type": "code",
718 | "execution_count": 18,
719 | "id": "colored-pencil",
720 | "metadata": {},
721 | "outputs": [
722 | {
723 | "name": "stdout",
724 | "output_type": "stream",
725 | "text": [
726 | "['programming']\n"
727 | ]
728 | }
729 | ],
730 | "source": [
731 | "txt = \"programming\"\n",
732 | "pattern = \"programmf?ing\" \n",
733 | "m = re.findall(pattern, txt)\n",
734 | "print(m)"
735 | ]
736 | },
737 | {
738 | "cell_type": "markdown",
739 | "id": "gorgeous-commitment",
740 | "metadata": {},
741 | "source": [
742 | "## {}\n",
743 | "#### {x} Repeat exactly x number of times.\n",
744 | "#### {x,} Repeat at least x times or more.\n",
745 | "#### {x, y} Repeat at least x times but no more than y times."
746 | ]
747 | },
748 | {
749 | "cell_type": "code",
750 | "execution_count": 19,
751 | "id": "relevant-johnson",
752 | "metadata": {},
753 | "outputs": [
754 | {
755 | "name": "stdout",
756 | "output_type": "stream",
757 | "text": [
758 | "['programmmmming']\n"
759 | ]
760 | }
761 | ],
762 | "source": [
763 | "txt = \"programmmmming\"\n",
764 | "pattern = \"programm{2,}ing\" \n",
765 | "m = re.findall(pattern, txt)\n",
766 | "print(m)"
767 | ]
768 | },
769 | {
770 | "cell_type": "markdown",
771 | "id": "fitting-intro",
772 | "metadata": {},
773 | "source": [
774 | "## Examples"
775 | ]
776 | },
777 | {
778 | "cell_type": "code",
779 | "execution_count": 20,
780 | "id": "married-brazil",
781 | "metadata": {},
782 | "outputs": [
783 | {
784 | "name": "stdout",
785 | "output_type": "stream",
786 | "text": [
787 | "['saeed.isa90@gmail.com']\n"
788 | ]
789 | }
790 | ],
791 | "source": [
792 | "txt = 'Please contact me at: saeed.isa90@gmail.com'\n",
793 | "pattern1 = '[a-zA-Z0-9\\.\\_]+@[a-zA-Z0-9]+.com'\n",
794 | "m = re.findall(pattern1, txt)\n",
795 | "print(m)"
796 | ]
797 | },
798 | {
799 | "cell_type": "code",
800 | "execution_count": 21,
801 | "id": "ranging-graph",
802 | "metadata": {},
803 | "outputs": [
804 | {
805 | "name": "stdout",
806 | "output_type": "stream",
807 | "text": [
808 | "['saeed.isa90@gmail.com']\n"
809 | ]
810 | }
811 | ],
812 | "source": [
813 | "txt = 'Please contact me at: saeed.isa90@gmail.com'\n",
814 | "pattern2 = '[\\w\\.]+@[\\w]+.com'\n",
815 | "m = re.findall(pattern2, txt)\n",
816 | "print(m)"
817 | ]
818 | },
819 | {
820 | "cell_type": "code",
821 | "execution_count": 22,
822 | "id": "pleasant-genre",
823 | "metadata": {},
824 | "outputs": [
825 | {
826 | "name": "stdout",
827 | "output_type": "stream",
828 | "text": [
829 | "['101010', '202020', '404040', '505050']\n"
830 | ]
831 | }
832 | ],
833 | "source": [
834 | "txt = '101010 202020 Saeed 404040 505050 Isa'\n",
835 | "pattern1 = '[0-9]+'\n",
836 | "m = re.findall(pattern1, txt)\n",
837 | "print(m)"
838 | ]
839 | },
840 | {
841 | "cell_type": "code",
842 | "execution_count": 23,
843 | "id": "welcome-confusion",
844 | "metadata": {},
845 | "outputs": [
846 | {
847 | "name": "stdout",
848 | "output_type": "stream",
849 | "text": [
850 | "['101010', '202020', '404040', '505050']\n"
851 | ]
852 | }
853 | ],
854 | "source": [
855 | "txt = '101010 202020 Saeed 404040 505050 Isa'\n",
856 | "pattern2 = '[\\d]+'\n",
857 | "m = re.findall(pattern2, txt)\n",
858 | "print(m)"
859 | ]
860 | }
861 | ],
862 | "metadata": {
863 | "kernelspec": {
864 | "display_name": "Python 3",
865 | "language": "python",
866 | "name": "python3"
867 | },
868 | "language_info": {
869 | "codemirror_mode": {
870 | "name": "ipython",
871 | "version": 3
872 | },
873 | "file_extension": ".py",
874 | "mimetype": "text/x-python",
875 | "name": "python",
876 | "nbconvert_exporter": "python",
877 | "pygments_lexer": "ipython3",
878 | "version": "3.8.3"
879 | }
880 | },
881 | "nbformat": 4,
882 | "nbformat_minor": 5
883 | }
884 |
--------------------------------------------------------------------------------