python_for_analytics

Форк
0
/
1.2_LEC_regular_expressions.ipynb 
1760 строк · 47.9 Кб
1
{
2
 "cells": [
3
  {
4
   "cell_type": "markdown",
5
   "metadata": {
6
    "id": "XQe7nsuY__r7"
7
   },
8
   "source": [
9
    "Определите длину каждого из этих списков"
10
   ]
11
  },
12
  {
13
   "cell_type": "code",
14
   "execution_count": null,
15
   "metadata": {
16
    "id": "TkYg2RmtA66L"
17
   },
18
   "outputs": [],
19
   "source": [
20
    "a = [1, 2, 3]\n",
21
    "b = [1, [2, 3]]\n",
22
    "c = []\n",
23
    "d = [1, 2, 3][1:]"
24
   ]
25
  },
26
  {
27
   "cell_type": "markdown",
28
   "metadata": {
29
    "id": "AMHNsoZd59w2"
30
   },
31
   "source": [
32
    "## Изменяемые и неизменяемые типы данных"
33
   ]
34
  },
35
  {
36
   "cell_type": "code",
37
   "execution_count": null,
38
   "metadata": {
39
    "id": "Ndf43O1F6ZSj"
40
   },
41
   "outputs": [],
42
   "source": [
43
    "some_names = ['John', 'James', 'Linda']  "
44
   ]
45
  },
46
  {
47
   "cell_type": "code",
48
   "execution_count": null,
49
   "metadata": {
50
    "colab": {
51
     "base_uri": "https://localhost:8080/"
52
    },
53
    "id": "pVlzWQlj4Hyx",
54
    "outputId": "7a4e774d-729e-466f-924e-aa8268bf3759"
55
   },
56
   "outputs": [
57
    {
58
     "data": {
59
      "text/plain": [
60
       "['James', 'John', 'Linda']"
61
      ]
62
     },
63
     "execution_count": 3,
64
     "metadata": {},
65
     "output_type": "execute_result"
66
    }
67
   ],
68
   "source": [
69
    "some_names.sort()\n",
70
    "\n",
71
    "some_names"
72
   ]
73
  },
74
  {
75
   "cell_type": "code",
76
   "execution_count": null,
77
   "metadata": {
78
    "colab": {
79
     "base_uri": "https://localhost:8080/"
80
    },
81
    "id": "z_U4KUt04H1n",
82
    "outputId": "ac82b08d-3402-49b4-8a42-4ef1acd7b1dc"
83
   },
84
   "outputs": [
85
    {
86
     "name": "stdout",
87
     "output_type": "stream",
88
     "text": [
89
      "hello world\n"
90
     ]
91
    }
92
   ],
93
   "source": [
94
    "my_string = 'Hello world'\n",
95
    "\n",
96
    "res = my_string.lower()\n",
97
    "\n",
98
    "print(res)"
99
   ]
100
  },
101
  {
102
   "cell_type": "code",
103
   "execution_count": null,
104
   "metadata": {
105
    "colab": {
106
     "base_uri": "https://localhost:8080/"
107
    },
108
    "id": "tIKGWXTQ4H4P",
109
    "outputId": "f9aed79b-5a5f-41d3-e4ff-00143c6def0e"
110
   },
111
   "outputs": [
112
    {
113
     "name": "stdout",
114
     "output_type": "stream",
115
     "text": [
116
      "['James', 'John', 'Linda']\n"
117
     ]
118
    }
119
   ],
120
   "source": [
121
    "\n",
122
    "res = sorted(some_names)\n",
123
    "\n",
124
    "print(res)"
125
   ]
126
  },
127
  {
128
   "cell_type": "code",
129
   "execution_count": null,
130
   "metadata": {
131
    "colab": {
132
     "base_uri": "https://localhost:8080/"
133
    },
134
    "id": "5TBq1es84H6_",
135
    "outputId": "2cba33c2-0de7-4112-ae38-b1ebcfddeded"
136
   },
137
   "outputs": [
138
    {
139
     "name": "stdout",
140
     "output_type": "stream",
141
     "text": [
142
      "['John', 'James', 'Linda']\n"
143
     ]
144
    }
145
   ],
146
   "source": [
147
    "some_names = ['John', 'James', 'Linda']  \n",
148
    "sorted(some_names)\n",
149
    "\n",
150
    "print(some_names)"
151
   ]
152
  },
153
  {
154
   "cell_type": "markdown",
155
   "metadata": {
156
    "id": "XOY7VKI357LA"
157
   },
158
   "source": [
159
    "Как можно \"разгладить\" список. Задачка на мышление  \n",
160
    "Должен получится результат:\n",
161
    "\n",
162
    "`['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']`"
163
   ]
164
  },
165
  {
166
   "cell_type": "code",
167
   "execution_count": 1,
168
   "metadata": {
169
    "id": "TL8qWkEI6mLE"
170
   },
171
   "outputs": [],
172
   "source": [
173
    "my_list = [['Екатеринбург', 'Москва'], ['Санкт-Петербург', 'Норильск'], ['Пермь', 'Астрахань']]"
174
   ]
175
  },
176
  {
177
   "cell_type": "code",
178
   "execution_count": 2,
179
   "metadata": {
180
    "colab": {
181
     "base_uri": "https://localhost:8080/"
182
    },
183
    "id": "gNqto9KB6sDG",
184
    "outputId": "7db5c4d5-703f-44c3-c6d8-32136f69b0ba"
185
   },
186
   "outputs": [
187
    {
188
     "name": "stdout",
189
     "output_type": "stream",
190
     "text": [
191
      "['Екатеринбург', 'Москва']\n",
192
      "Екатеринбург\n",
193
      "Москва\n",
194
      "['Санкт-Петербург', 'Норильск']\n",
195
      "Санкт-Петербург\n",
196
      "Норильск\n",
197
      "['Пермь', 'Астрахань']\n",
198
      "Пермь\n",
199
      "Астрахань\n"
200
     ]
201
    },
202
    {
203
     "data": {
204
      "text/plain": [
205
       "['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']"
206
      ]
207
     },
208
     "execution_count": 2,
209
     "metadata": {},
210
     "output_type": "execute_result"
211
    }
212
   ],
213
   "source": [
214
    "res = []\n",
215
    "\n",
216
    "for el in my_list:\n",
217
    "    print(el)\n",
218
    "    for city in el:\n",
219
    "        print(city)\n",
220
    "        res.append(city)\n",
221
    "\n",
222
    "res"
223
   ]
224
  },
225
  {
226
   "cell_type": "code",
227
   "execution_count": null,
228
   "metadata": {
229
    "colab": {
230
     "base_uri": "https://localhost:8080/"
231
    },
232
    "id": "xaM-vnUR7IIK",
233
    "outputId": "b4762d87-0cc3-4e10-a33f-276318bda68e"
234
   },
235
   "outputs": [
236
    {
237
     "name": "stdout",
238
     "output_type": "stream",
239
     "text": [
240
      "['Екатеринбург', 'Москва']\n",
241
      "['Санкт-Петербург', 'Норильск']\n",
242
      "['Пермь', 'Астрахань']\n"
243
     ]
244
    },
245
    {
246
     "data": {
247
      "text/plain": [
248
       "['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']"
249
      ]
250
     },
251
     "execution_count": 13,
252
     "metadata": {},
253
     "output_type": "execute_result"
254
    }
255
   ],
256
   "source": [
257
    "res = []\n",
258
    "\n",
259
    "for el in my_list:\n",
260
    "    print(el)\n",
261
    "    res += el\n",
262
    "\n",
263
    "res"
264
   ]
265
  },
266
  {
267
   "cell_type": "code",
268
   "execution_count": null,
269
   "metadata": {
270
    "colab": {
271
     "base_uri": "https://localhost:8080/"
272
    },
273
    "id": "eqDlz1KP7aCs",
274
    "outputId": "a56008f6-9694-49fe-fa32-8f1dabaedf45"
275
   },
276
   "outputs": [
277
    {
278
     "data": {
279
      "text/plain": [
280
       "[1, 2, 3, 4]"
281
      ]
282
     },
283
     "execution_count": 14,
284
     "metadata": {},
285
     "output_type": "execute_result"
286
    }
287
   ],
288
   "source": [
289
    "[1, 2] + [3, 4]"
290
   ]
291
  },
292
  {
293
   "cell_type": "code",
294
   "execution_count": null,
295
   "metadata": {
296
    "colab": {
297
     "base_uri": "https://localhost:8080/"
298
    },
299
    "id": "ER7W-cvn7k-H",
300
    "outputId": "e9785de8-cdf9-41e0-8545-235875696dbc"
301
   },
302
   "outputs": [
303
    {
304
     "data": {
305
      "text/plain": [
306
       "['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']"
307
      ]
308
     },
309
     "execution_count": 17,
310
     "metadata": {},
311
     "output_type": "execute_result"
312
    }
313
   ],
314
   "source": [
315
    "sum(my_list, [])"
316
   ]
317
  },
318
  {
319
   "cell_type": "code",
320
   "execution_count": null,
321
   "metadata": {
322
    "colab": {
323
     "base_uri": "https://localhost:8080/"
324
    },
325
    "id": "embfzDW873q5",
326
    "outputId": "82140367-23c9-4afc-d158-e531b4d5886c"
327
   },
328
   "outputs": [
329
    {
330
     "name": "stdout",
331
     "output_type": "stream",
332
     "text": [
333
      "Help on built-in function sum in module builtins:\n",
334
      "\n",
335
      "sum(iterable, /, start=0)\n",
336
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
337
      "    \n",
338
      "    When the iterable is empty, return the start value.\n",
339
      "    This function is intended specifically for use with numeric values and may\n",
340
      "    reject non-numeric types.\n",
341
      "\n"
342
     ]
343
    }
344
   ],
345
   "source": [
346
    "help(sum)"
347
   ]
348
  },
349
  {
350
   "cell_type": "markdown",
351
   "metadata": {
352
    "id": "rLyLP81sEeYY"
353
   },
354
   "source": [
355
    "## Гипотеза Сиракуз\n",
356
    "https://ru.wikipedia.org/wiki/Гипотеза_Коллатца  \n",
357
    "Гипотеза Сиракуз гласит, что любое натуральное число сводится к единице при следующих действиях над ним: \n",
358
    "\n",
359
    "а) если число четное, то разделить его пополам, \n",
360
    "\n",
361
    "б) если число нечетное, то умножить его на 3, прибавить 1 и результат разделить на 2. \n",
362
    "\n",
363
    "Над вновь полученным числом вновь повторить действия a) или б) в зависимости от четности числа. Рано или поздно число станет равным 1.\n",
364
    "\n",
365
    "Напишем программу, проверяющую гипотезу Сиракуз. Пусть пользователь вводит любое натуральное число. Будем выполнять в цикле над ним вышеуказанные действия, пока оно не станет равным 1. Если гипотеза верна, то рано или поздно цикл закончится, а если нет - то произойдет зацикливание программы.\n",
366
    "\n",
367
    "https://www.youtube.com/watch?v=QgzBDZwanWA"
368
   ]
369
  },
370
  {
371
   "cell_type": "code",
372
   "execution_count": null,
373
   "metadata": {
374
    "colab": {
375
     "base_uri": "https://localhost:8080/"
376
    },
377
    "id": "fNPueODdEeYY",
378
    "outputId": "57122e88-bdb0-4d25-dbe3-ac774896b6c3"
379
   },
380
   "outputs": [
381
    {
382
     "name": "stdout",
383
     "output_type": "stream",
384
     "text": [
385
      "9789690303392599179036234\n",
386
      "1.0 367\n"
387
     ]
388
    }
389
   ],
390
   "source": [
391
    "n = int(input())\n",
392
    "counter = 0\n",
393
    "while n != 1:\n",
394
    "    counter += 1\n",
395
    "    if n % 2 == 0:\n",
396
    "        n /= 2\n",
397
    "    else:\n",
398
    "        n = (n * 3 + 1) / 2\n",
399
    "print(n, counter)"
400
   ]
401
  },
402
  {
403
   "cell_type": "markdown",
404
   "metadata": {
405
    "id": "E6ywQi0G5-o1"
406
   },
407
   "source": [
408
    "## else и циклы"
409
   ]
410
  },
411
  {
412
   "cell_type": "markdown",
413
   "metadata": {
414
    "id": "rrt2CXpIxlJz"
415
   },
416
   "source": [
417
    "Напишем игру \"Угадай число\""
418
   ]
419
  },
420
  {
421
   "cell_type": "code",
422
   "execution_count": null,
423
   "metadata": {
424
    "colab": {
425
     "base_uri": "https://localhost:8080/"
426
    },
427
    "id": "8oU2aES0g53U",
428
    "outputId": "76f829a3-fd71-4f77-e168-af77cadf9b8e"
429
   },
430
   "outputs": [
431
    {
432
     "name": "stdout",
433
     "output_type": "stream",
434
     "text": [
435
      "18\n",
436
      "Назови свой вариант18\n",
437
      "Вы победили!\n"
438
     ]
439
    }
440
   ],
441
   "source": [
442
    "import random\n",
443
    "\n",
444
    "number = random.randint(1, 100)\n",
445
    "print(number)\n",
446
    "max_tries = 3\n",
447
    "tries = 0\n",
448
    "\n",
449
    "while tries < max_tries:\n",
450
    "    guess = int(input('Назови свой вариант'))\n",
451
    "    tries += 1\n",
452
    "    if guess < number:\n",
453
    "        print('Загаданное число больше')\n",
454
    "    elif guess > number:\n",
455
    "        print('Загаданное число меньше')\n",
456
    "    else:\n",
457
    "        print('Вы победили!')\n",
458
    "        break\n",
459
    "else: \n",
460
    "    print('Вы проиграли')\n",
461
    "    print('Было загадано число:', number)"
462
   ]
463
  },
464
  {
465
   "cell_type": "code",
466
   "execution_count": null,
467
   "metadata": {
468
    "colab": {
469
     "base_uri": "https://localhost:8080/"
470
    },
471
    "id": "qzwdSp8K-vzh",
472
    "outputId": "83a592fa-b062-4f4e-a55e-f2db580885bc"
473
   },
474
   "outputs": [
475
    {
476
     "name": "stdout",
477
     "output_type": "stream",
478
     "text": [
479
      "0\n",
480
      "Found even number 2\n"
481
     ]
482
    }
483
   ],
484
   "source": [
485
    "numbers = [2, 3, 5]\n",
486
    "position = 0\n",
487
    "while position < len(numbers):\n",
488
    "  print(position)\n",
489
    "  number = numbers[position]\n",
490
    "  if number % 2 == 0:\n",
491
    "    print('Found even number', number)\n",
492
    "    break\n",
493
    "  position += 1\n",
494
    "else:\n",
495
    "  print('No even number found')"
496
   ]
497
  },
498
  {
499
   "cell_type": "code",
500
   "execution_count": null,
501
   "metadata": {
502
    "colab": {
503
     "base_uri": "https://localhost:8080/"
504
    },
505
    "id": "Kw49bjVz_GIM",
506
    "outputId": "e57227ac-53d3-4a4f-9f8b-84396169227e"
507
   },
508
   "outputs": [
509
    {
510
     "name": "stdout",
511
     "output_type": "stream",
512
     "text": [
513
      "Found even number 2\n"
514
     ]
515
    }
516
   ],
517
   "source": [
518
    "numbers = [2, 3, 5]\n",
519
    "for number in numbers:\n",
520
    "  if number % 2 == 0:\n",
521
    "    print('Found even number', number)\n",
522
    "    break\n",
523
    "else:\n",
524
    "  print('No even number found')"
525
   ]
526
  },
527
  {
528
   "cell_type": "markdown",
529
   "metadata": {
530
    "id": "v23yWHR_7yO3"
531
   },
532
   "source": [
533
    "Выведем на экран список всех слов длиннее n букв из текста"
534
   ]
535
  },
536
  {
537
   "cell_type": "code",
538
   "execution_count": null,
539
   "metadata": {
540
    "id": "ZfRx-Pag7wjm"
541
   },
542
   "outputs": [],
543
   "source": [
544
    "text = 'Python — высокоуровневый язык программирования, ориентированный на повышение производительности разработчика и читаемости кода.'\n",
545
    "n = 4"
546
   ]
547
  },
548
  {
549
   "cell_type": "code",
550
   "execution_count": null,
551
   "metadata": {
552
    "colab": {
553
     "base_uri": "https://localhost:8080/"
554
    },
555
    "id": "0SwJmvOG8FVs",
556
    "outputId": "312c2629-017f-4304-b53b-beca76100b70"
557
   },
558
   "outputs": [
559
    {
560
     "name": "stdout",
561
     "output_type": "stream",
562
     "text": [
563
      "Python\n",
564
      "Python\n",
565
      "—\n",
566
      "—\n",
567
      "высокоуровневый\n",
568
      "высокоуровневый\n",
569
      "язык\n",
570
      "язык\n",
571
      "программирования,\n",
572
      "программирования\n",
573
      "ориентированный\n",
574
      "ориентированный\n",
575
      "на\n",
576
      "на\n",
577
      "повышение\n",
578
      "повышение\n",
579
      "производительности\n",
580
      "производительности\n",
581
      "разработчика\n",
582
      "разработчика\n",
583
      "и\n",
584
      "и\n",
585
      "читаемости\n",
586
      "читаемости\n",
587
      "кода.\n",
588
      "кода\n"
589
     ]
590
    },
591
    {
592
     "data": {
593
      "text/plain": [
594
       "['Python',\n",
595
       " 'высокоуровневый',\n",
596
       " 'программирования',\n",
597
       " 'ориентированный',\n",
598
       " 'повышение',\n",
599
       " 'производительности',\n",
600
       " 'разработчика',\n",
601
       " 'читаемости']"
602
      ]
603
     },
604
     "execution_count": 32,
605
     "metadata": {},
606
     "output_type": "execute_result"
607
    }
608
   ],
609
   "source": [
610
    "res = []\n",
611
    "\n",
612
    "for word in text.split():\n",
613
    "    # print(word)\n",
614
    "    word = word.strip(',.!?')\n",
615
    "    # print(word)\n",
616
    "    if len(word) > n:\n",
617
    "        res.append(word)\n",
618
    "\n",
619
    "res"
620
   ]
621
  },
622
  {
623
   "cell_type": "markdown",
624
   "metadata": {
625
    "id": "1dYKDsmV_U4o"
626
   },
627
   "source": [
628
    "## Сумма элементов по главной диагонали в матрице"
629
   ]
630
  },
631
  {
632
   "cell_type": "code",
633
   "execution_count": null,
634
   "metadata": {
635
    "id": "XcpgxMI19KLl"
636
   },
637
   "outputs": [],
638
   "source": [
639
    "data = [\n",
640
    "    [13, 25, 23, 34],\n",
641
    "    [45, 32, 44, 47],\n",
642
    "    [12, 33, 23, 95],\n",
643
    "    [13, 53, 34, 35]\n",
644
    "]"
645
   ]
646
  },
647
  {
648
   "cell_type": "code",
649
   "execution_count": null,
650
   "metadata": {
651
    "colab": {
652
     "base_uri": "https://localhost:8080/"
653
    },
654
    "id": "tSlpdpFf9S7x",
655
    "outputId": "684b7fef-525a-4860-d99e-698cbd733bdb"
656
   },
657
   "outputs": [
658
    {
659
     "data": {
660
      "text/plain": [
661
       "103"
662
      ]
663
     },
664
     "execution_count": 35,
665
     "metadata": {},
666
     "output_type": "execute_result"
667
    }
668
   ],
669
   "source": [
670
    "result = 0\n",
671
    "index = 0\n",
672
    "for row in data:\n",
673
    "    result += row[index]\n",
674
    "    index += 1\n",
675
    "result"
676
   ]
677
  },
678
  {
679
   "cell_type": "code",
680
   "execution_count": null,
681
   "metadata": {
682
    "colab": {
683
     "base_uri": "https://localhost:8080/"
684
    },
685
    "id": "Ac9wLlZsA_2e",
686
    "outputId": "5f5da0fa-b2ea-4537-8894-b33e7ef5f2f6"
687
   },
688
   "outputs": [
689
    {
690
     "data": {
691
      "text/plain": [
692
       "124"
693
      ]
694
     },
695
     "execution_count": 36,
696
     "metadata": {},
697
     "output_type": "execute_result"
698
    }
699
   ],
700
   "source": [
701
    "result = 0\n",
702
    "index = -1\n",
703
    "for row in data:\n",
704
    "    result += row[index]\n",
705
    "    index -= 1\n",
706
    "result"
707
   ]
708
  },
709
  {
710
   "cell_type": "markdown",
711
   "metadata": {
712
    "id": "ZhsS0uFL_J9l"
713
   },
714
   "source": [
715
    "## Выведем фамилии построчно с указанием профессии в виде:\n",
716
    "```\n",
717
    "IT:  \n",
718
    "Гейтс  \n",
719
    "Джобс  \n",
720
    "Возняк  \n",
721
    "\n",
722
    "Физика:  \n",
723
    "Эйнштейн  \n",
724
    "Фейнман  \n",
725
    "\n",
726
    "Математика:  \n",
727
    "Эвклид  \n",
728
    "Ньютон\n",
729
    "```\n",
730
    "\n"
731
   ]
732
  },
733
  {
734
   "cell_type": "code",
735
   "execution_count": null,
736
   "metadata": {
737
    "id": "z4y6_PVy_S0v"
738
   },
739
   "outputs": [],
740
   "source": [
741
    "professions = ['IT', 'Физика', 'Математика']\n",
742
    "persons = [['Гейтс', 'Джобс', 'Возняк'], ['Эйнштейн', 'Фейнман'], ['Эвклид', 'Ньютон']]"
743
   ]
744
  },
745
  {
746
   "cell_type": "code",
747
   "execution_count": null,
748
   "metadata": {
749
    "colab": {
750
     "base_uri": "https://localhost:8080/"
751
    },
752
    "id": "4dXBJV0D_Pr3",
753
    "outputId": "fbe1bc17-1140-4acd-f3d6-49693ea096ee"
754
   },
755
   "outputs": [
756
    {
757
     "name": "stdout",
758
     "output_type": "stream",
759
     "text": [
760
      "IT:\n",
761
      "Гейтс\n",
762
      "Джобс\n",
763
      "Возняк\n",
764
      "\n",
765
      "Физика:\n",
766
      "Эйнштейн\n",
767
      "Фейнман\n",
768
      "\n",
769
      "Математика:\n",
770
      "Эвклид\n",
771
      "Ньютон\n",
772
      "\n"
773
     ]
774
    }
775
   ],
776
   "source": [
777
    "for pro, names in zip(professions, persons):\n",
778
    "    print(f'{pro}:')\n",
779
    "    for name in names:\n",
780
    "        print(name)\n",
781
    "    print()"
782
   ]
783
  },
784
  {
785
   "cell_type": "code",
786
   "execution_count": null,
787
   "metadata": {
788
    "colab": {
789
     "base_uri": "https://localhost:8080/"
790
    },
791
    "id": "nxT-J2s4CO1b",
792
    "outputId": "8a317555-630d-4878-ec96-7a6ce813ca87"
793
   },
794
   "outputs": [
795
    {
796
     "name": "stdout",
797
     "output_type": "stream",
798
     "text": [
799
      "IT:\n",
800
      "Гейтс\n",
801
      "Джобс\n",
802
      "Возняк\n",
803
      "\n",
804
      "Физика:\n",
805
      "Эйнштейн\n",
806
      "Фейнман\n",
807
      "\n",
808
      "Математика:\n",
809
      "Эвклид\n",
810
      "Ньютон\n",
811
      "\n"
812
     ]
813
    }
814
   ],
815
   "source": [
816
    "for pro, names in zip(professions, persons):\n",
817
    "    print(f'{pro}:')\n",
818
    "    print('\\n'.join(names))\n",
819
    "    print()"
820
   ]
821
  },
822
  {
823
   "cell_type": "code",
824
   "execution_count": null,
825
   "metadata": {
826
    "colab": {
827
     "base_uri": "https://localhost:8080/",
828
     "height": 36
829
    },
830
    "id": "D5G9r-oZCcv9",
831
    "outputId": "5ea7a699-5d98-479d-fa9f-38c9882419a7"
832
   },
833
   "outputs": [
834
    {
835
     "data": {
836
      "application/vnd.google.colaboratory.intrinsic+json": {
837
       "type": "string"
838
      },
839
      "text/plain": [
840
       "'sdgsd?sdgsdg?sdgsdgg4w3'"
841
      ]
842
     },
843
     "execution_count": 43,
844
     "metadata": {},
845
     "output_type": "execute_result"
846
    }
847
   ],
848
   "source": [
849
    "'?'.join(['sdgsd', 'sdgsdg', 'sdgsdgg4w3'])"
850
   ]
851
  },
852
  {
853
   "cell_type": "markdown",
854
   "metadata": {
855
    "id": "nJCfRLdINDG-"
856
   },
857
   "source": [
858
    "Необходимо у пользователя запрашивать набор чисел разделенных пробелом. В результате в отсортированном порядке должны выводиться числа, которые повторяются в вводе более одного раза."
859
   ]
860
  },
861
  {
862
   "cell_type": "code",
863
   "execution_count": null,
864
   "metadata": {
865
    "colab": {
866
     "base_uri": "https://localhost:8080/"
867
    },
868
    "id": "-X1rbA4qNCrP",
869
    "outputId": "5bd9ac31-f764-4bf7-ab09-e1dac14fc513"
870
   },
871
   "outputs": [
872
    {
873
     "name": "stdout",
874
     "output_type": "stream",
875
     "text": [
876
      "Введите числа через пробел11 222 333 3 3 3 4 45 5 5\n",
877
      "['11', '222', '333', '3', '3', '3', '4', '45', '5', '5']\n",
878
      "[3, 5]\n"
879
     ]
880
    }
881
   ],
882
   "source": [
883
    "numbers = input('Введите числа через пробел').split()\n",
884
    "print(numbers)\n",
885
    "res = []\n",
886
    "\n",
887
    "for number in numbers:\n",
888
    "    if numbers.count(number) > 1 and int(number) not in res:\n",
889
    "        res.append(int(number))\n",
890
    "\n",
891
    "res.sort()\n",
892
    "print(res)"
893
   ]
894
  },
895
  {
896
   "cell_type": "code",
897
   "execution_count": null,
898
   "metadata": {
899
    "colab": {
900
     "base_uri": "https://localhost:8080/"
901
    },
902
    "id": "dsdjawt8D5VU",
903
    "outputId": "9acb4389-817a-48ed-cb85-e8b7a2e70702"
904
   },
905
   "outputs": [
906
    {
907
     "name": "stdout",
908
     "output_type": "stream",
909
     "text": [
910
      "['1', '1', '1', '2', '2', '3', '444', '55', '1111', '111', '11', '4', '56']\n",
911
      "2\n"
912
     ]
913
    }
914
   ],
915
   "source": [
916
    "print(numbers)\n",
917
    "\n",
918
    "print(numbers.count('2'))"
919
   ]
920
  },
921
  {
922
   "cell_type": "markdown",
923
   "metadata": {
924
    "id": "HskSJH7qwPDv"
925
   },
926
   "source": [
927
    "# Регулярные выражения\n",
928
    "Регулярные выражения (Regular Expressions, regex) – это строки, содержащие совокупность обычных символов и специальных метасимволов, которые описывают определенный шаблон.\n",
929
    "\n",
930
    "Эти шаблоны, к примеру, можно использовать для того, чтобы:  \n",
931
    "- находить и заменять что-то в текстовых данных;  \n",
932
    "- валидировать строковые поля.  \n",
933
    "\n",
934
    "Шаблоны могут быть настолько сложными, что другими способами определить их будет крайне трудно.\n",
935
    "\n",
936
    "Одна из особенностей регулярных выражений в их универсальности, стоит вам выучить синтаксис, и вы сможете применять их в любом (почти) языке программирования (JavaScript, Java, VB, C #, C / C++, Python, Perl, Ruby, Delphi, R, Tcl, и многих других). Небольшие отличия касаются только наиболее продвинутых функций и версий синтаксиса, поддерживаемых движком."
937
   ]
938
  },
939
  {
940
   "cell_type": "markdown",
941
   "metadata": {
942
    "id": "bmNLm5bMwPDw"
943
   },
944
   "source": [
945
    ">Если у вас есть проблема, и вы собираетесь ее решать с помощью регулярных выражений, тогда у вас будет уже две проблемы.\n",
946
    "\n",
947
    "<cite>Шутка из интернетов (не шутка)</cite>. [Вот так](https://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html) может выглядеть страшная регулярка.\n"
948
   ]
949
  },
950
  {
951
   "cell_type": "markdown",
952
   "metadata": {
953
    "id": "JOfSwksmwPDw"
954
   },
955
   "source": [
956
    "Основы синтаксиса регулярных выражений"
957
   ]
958
  },
959
  {
960
   "cell_type": "markdown",
961
   "metadata": {
962
    "id": "hVqMlffSwPDx"
963
   },
964
   "source": [
965
    "<table>\n",
966
    "<tbody>\n",
967
    "<tr>\n",
968
    "<td width=\"20%\"><b>Последовательность</b></td>\n",
969
    "<td width=\"60%\"><b>Описание</b></td>\n",
970
    "<td width=\"20%\"><b>Аналог с []</b></td>\n",
971
    "</tr>\n",
972
    "<tr>\n",
973
    "<td>\\d</td>\n",
974
    "<td>Любая цифра</td>\n",
975
    "<td>[0-9]</td>\n",
976
    "</tr>\n",
977
    "<tr>\n",
978
    "<td>\\D</td>\n",
979
    "<td>Всё что угодно, кроме цифры</td>\n",
980
    "<td>[^0-9]</td>\n",
981
    "</tr>\n",
982
    "<tr>\n",
983
    "<td>\\s</td>\n",
984
    "<td>Любой пробельный символ</td>\n",
985
    "<td>[ \\t\\n\\r\\f\\v]</td>\n",
986
    "</tr>\n",
987
    "<tr>\n",
988
    "<td>\\S</td>\n",
989
    "<td>Любой непробельный символ</td>\n",
990
    "<td>[^ \\t\\n\\r\\f\\v]</td>\n",
991
    "</tr>\n",
992
    "<tr>\n",
993
    "<td>\\w</td>\n",
994
    "<td>Любая буква, цифра, знак подчёркивания</td>\n",
995
    "<td>[a-zA-Z0-9_]</td>\n",
996
    "</tr>\n",
997
    "<tr>\n",
998
    "<td>\\W</td>\n",
999
    "<td>Всё что угодно, кроме букв, цифр и знака подчёркивания</td>\n",
1000
    "<td>[^a-zA-Z0-9_]</td>\n",
1001
    "</tr>\n",
1002
    "</tbody>\n",
1003
    "</table>"
1004
   ]
1005
  },
1006
  {
1007
   "cell_type": "markdown",
1008
   "metadata": {
1009
    "id": "m-f9dwO1wPDx"
1010
   },
1011
   "source": [
1012
    "<table>\n",
1013
    "<tbody>\n",
1014
    "<tr>\n",
1015
    "<td width=\"10%\"><b>Символ</b></td>\n",
1016
    "<td width=\"50%\"><b>Пояснение</b></td>\n",
1017
    "<td width=\"20%\"><b>Пример выражения</b></td>\n",
1018
    "<td width=\"20%\"><b>Пример строки</b></td>\n",
1019
    "</tr>\n",
1020
    "<tr>\n",
1021
    "<td>.</td>\n",
1022
    "<td>Любой символ</td>\n",
1023
    "<td>...</td>\n",
1024
    "<td>A!#</td>\n",
1025
    "</tr>\n",
1026
    "<tr>\n",
1027
    "<td>*</td>\n",
1028
    "<td>Ноль и более&nbsp;совпадений с выражением, заданным в качестве образца&nbsp;</td>\n",
1029
    "<td>(123)*</td>\n",
1030
    "<td>123123123</td>\n",
1031
    "</tr>\n",
1032
    "<tr>\n",
1033
    "<td>+</td>\n",
1034
    "<td>Одно и более&nbsp;совпадений с выражением, заданным в качестве образца&nbsp;</td>\n",
1035
    "<td>(Ура!)+</td>\n",
1036
    "<td>Ура!Ура!</td>\n",
1037
    "</tr>\n",
1038
    "<tr>\n",
1039
    "<td>?</td>\n",
1040
    "<td>Ноль или одно&nbsp;совпадение с выражением, заданным в качестве образца&nbsp;</td>\n",
1041
    "<td>(один)?</td>\n",
1042
    "<td>один</td>\n",
1043
    "</tr>\n",
1044
    "<tr>\n",
1045
    "<td>[ ]</td>\n",
1046
    "<td>Совпадение с любым из символов, заключённым в скобки</td>\n",
1047
    "<td>[a-z]</td>\n",
1048
    "<td>b</td>\n",
1049
    "</tr>\n",
1050
    "<tr>\n",
1051
    "<td>[^ ]</td>\n",
1052
    "<td>Совпадение с любым из символов, отсутствующим в скобках</td>\n",
1053
    "<td>[^a-z]</td>\n",
1054
    "<td>5</td>\n",
1055
    "</tr>\n",
1056
    "<tr>\n",
1057
    "<td>\\</td>\n",
1058
    "<td>Экранирует специальные символы (т.е. позволяет использовать символы типа '.', '*', '?' в роли обычных элементов строки)</td>\n",
1059
    "<td>\\*</td>\n",
1060
    "<td>*</td>\n",
1061
    "</tr>\n",
1062
    "</tbody>\n",
1063
    "</table>"
1064
   ]
1065
  },
1066
  {
1067
   "cell_type": "markdown",
1068
   "metadata": {
1069
    "id": "LrYMvaQkwPDy"
1070
   },
1071
   "source": [
1072
    "Квантификаторы  \n",
1073
    "Квантификатор после символа или группы определяет, сколько раз предшествующее выражение может встречаться.\n",
1074
    "\n",
1075
    "    {n,m}        общее выражение, повторений может быть от n до m включительно.\n",
1076
    "    {n,}        общее выражение, n и более повторений.\n",
1077
    "    {,m}        общее выражение, не более m повторений.\n",
1078
    "    {n}        общее выражение, ровно n повторений"
1079
   ]
1080
  },
1081
  {
1082
   "cell_type": "code",
1083
   "execution_count": 3,
1084
   "metadata": {
1085
    "id": "Ld5A8OoLwPDy"
1086
   },
1087
   "outputs": [],
1088
   "source": [
1089
    "# импортируем модуль для работы с регулярками в python\n",
1090
    "import re"
1091
   ]
1092
  },
1093
  {
1094
   "cell_type": "markdown",
1095
   "metadata": {
1096
    "id": "MsJruxlEwPDy"
1097
   },
1098
   "source": [
1099
    "**raw string** – подавляет значение escape-последовательностей, обозначается префиксом r перед обычной строкой. \n",
1100
    "Настоятельно рекомендуется использовать всегда при работе с регулярными выражениями для избежания проблем."
1101
   ]
1102
  },
1103
  {
1104
   "cell_type": "markdown",
1105
   "metadata": {
1106
    "id": "YExnzPsuJ8dL"
1107
   },
1108
   "source": [
1109
    "Функция `re.findall(pattern, string)` – ищет во всем тексте, возвращает список всех найденных совпадений"
1110
   ]
1111
  },
1112
  {
1113
   "cell_type": "markdown",
1114
   "metadata": {
1115
    "id": "cgmYzR4WwPDz"
1116
   },
1117
   "source": [
1118
    "Найдем хэштеги в твите"
1119
   ]
1120
  },
1121
  {
1122
   "cell_type": "code",
1123
   "execution_count": 4,
1124
   "metadata": {
1125
    "id": "zem_a2I4wPDz"
1126
   },
1127
   "outputs": [],
1128
   "source": [
1129
    "# найдем хештеги в тексте\n",
1130
    "tweet = 'когда #эпидемия, то обязательно #оставайсядома'"
1131
   ]
1132
  },
1133
  {
1134
   "cell_type": "code",
1135
   "execution_count": 5,
1136
   "metadata": {
1137
    "colab": {
1138
     "base_uri": "https://localhost:8080/"
1139
    },
1140
    "id": "iseEgiJSwPDz",
1141
    "outputId": "b304204c-a48e-4508-fa68-421d55c7f656"
1142
   },
1143
   "outputs": [
1144
    {
1145
     "data": {
1146
      "text/plain": [
1147
       "['#эпидемия', '#оставайсядома']"
1148
      ]
1149
     },
1150
     "execution_count": 5,
1151
     "metadata": {},
1152
     "output_type": "execute_result"
1153
    }
1154
   ],
1155
   "source": [
1156
    "re.findall(r'#\\w+', tweet)"
1157
   ]
1158
  },
1159
  {
1160
   "cell_type": "markdown",
1161
   "metadata": {
1162
    "id": "yufSrTvkHwdo"
1163
   },
1164
   "source": [
1165
    "Вытащим номера телефонов и текста"
1166
   ]
1167
  },
1168
  {
1169
   "cell_type": "code",
1170
   "execution_count": null,
1171
   "metadata": {
1172
    "colab": {
1173
     "base_uri": "https://localhost:8080/"
1174
    },
1175
    "id": "CJPTRo9EwPDz",
1176
    "outputId": "5f0e361e-39e3-4a9e-802a-6b5a99c9e519"
1177
   },
1178
   "outputs": [
1179
    {
1180
     "data": {
1181
      "text/plain": [
1182
       "['8-943-342-23-32', '8-323-432-23-67']"
1183
      ]
1184
     },
1185
     "execution_count": 52,
1186
     "metadata": {},
1187
     "output_type": "execute_result"
1188
    }
1189
   ],
1190
   "source": [
1191
    "phone_numbers = 'Мария: 8-943-342-23-32 Александр: 8-323-432-23-67'\n",
1192
    "\n",
1193
    "phone_pattern = r'\\d-\\d{3}-\\d{3}-\\d{2}-\\d{2}'\n",
1194
    "re.findall(phone_pattern, phone_numbers)"
1195
   ]
1196
  },
1197
  {
1198
   "cell_type": "markdown",
1199
   "metadata": {
1200
    "id": "c8DfxgFNH1RX"
1201
   },
1202
   "source": [
1203
    "[] - найдем слово во всем склонениях\n"
1204
   ]
1205
  },
1206
  {
1207
   "cell_type": "code",
1208
   "execution_count": 7,
1209
   "metadata": {
1210
    "colab": {
1211
     "base_uri": "https://localhost:8080/"
1212
    },
1213
    "id": "MPp5loWIwPD0",
1214
    "outputId": "2ef29489-75a8-414b-ae10-e337728d7e6c"
1215
   },
1216
   "outputs": [
1217
    {
1218
     "data": {
1219
      "text/plain": [
1220
       "['регулярные выражения', 'регулярное выражение', 'регулярных выражений']"
1221
      ]
1222
     },
1223
     "execution_count": 7,
1224
     "metadata": {},
1225
     "output_type": "execute_result"
1226
    }
1227
   ],
1228
   "source": [
1229
    "text = \"\"\"Что такое регулярные выражения и как их использовать? \n",
1230
    "Говоря простым языком, регулярное выражение — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
1231
    "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
1232
    "Так что изучение регулярных выражений рано или поздно пригодится.\"\"\"\n",
1233
    "pattern = 'регулярн[а-я]+ выражен[а-я]+'\n",
1234
    "re.findall(pattern, text)"
1235
   ]
1236
  },
1237
  {
1238
   "cell_type": "markdown",
1239
   "metadata": {
1240
    "id": "DQgnIgafK85c"
1241
   },
1242
   "source": [
1243
    "Функция `re.sub(pattern, repl, string)` – ищет шаблон в строке и заменяет его на указанную подстроку."
1244
   ]
1245
  },
1246
  {
1247
   "cell_type": "markdown",
1248
   "metadata": {
1249
    "id": "0EgIDMFQwPD1"
1250
   },
1251
   "source": [
1252
    "Простой способ удалить все служебные символы"
1253
   ]
1254
  },
1255
  {
1256
   "cell_type": "code",
1257
   "execution_count": 6,
1258
   "metadata": {
1259
    "colab": {
1260
     "base_uri": "https://localhost:8080/"
1261
    },
1262
    "id": "I8PfgKZVwPD1",
1263
    "outputId": "32a1eaac-6bfe-4bcc-fbd8-572b3833fb5f"
1264
   },
1265
   "outputs": [
1266
    {
1267
     "name": "stdout",
1268
     "output_type": "stream",
1269
     "text": [
1270
      "Что такое регулярные выражения и как их использовать \n",
1271
      "Говоря простым языком регулярное выражение  это последовательность символов используемая для поиска и замены текста в строке или файле Как уже было упомянуто\n",
1272
      "их поддерживает множество языков общего назначения Python Perl R\n",
1273
      "Так что изучение регулярных выражений рано или поздно пригодится\n"
1274
     ]
1275
    }
1276
   ],
1277
   "source": [
1278
    "text = \"\"\"Что такое регулярные выражения и как их использовать? \n",
1279
    "Говоря простым языком, регулярное выражение — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
1280
    "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
1281
    "Так что изучение регулярных выражений рано или поздно пригодится.\"\"\"\n",
1282
    "\n",
1283
    "print(re.sub(r'[^\\w\\s]', '', text))"
1284
   ]
1285
  },
1286
  {
1287
   "cell_type": "markdown",
1288
   "metadata": {
1289
    "id": "fq2RAOdcwPD0"
1290
   },
1291
   "source": [
1292
    "Произведем замену \"Регулярные выражения\" во всех формах на \"regex\""
1293
   ]
1294
  },
1295
  {
1296
   "cell_type": "code",
1297
   "execution_count": null,
1298
   "metadata": {
1299
    "id": "HCekNfNGwPD0"
1300
   },
1301
   "outputs": [],
1302
   "source": [
1303
    "text = \"\"\"Что такое регулярные выражения и как их использовать? \n",
1304
    "Говоря простым языком, регулярное выражение — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
1305
    "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
1306
    "Так что изучение регулярных выражений рано или поздно пригодится.\"\"\""
1307
   ]
1308
  },
1309
  {
1310
   "cell_type": "code",
1311
   "execution_count": null,
1312
   "metadata": {
1313
    "colab": {
1314
     "base_uri": "https://localhost:8080/"
1315
    },
1316
    "id": "tORUuPGHIA3u",
1317
    "outputId": "49631134-8c64-48ec-f223-641926de3c53"
1318
   },
1319
   "outputs": [
1320
    {
1321
     "name": "stdout",
1322
     "output_type": "stream",
1323
     "text": [
1324
      "Что такое regex и как их использовать? \n",
1325
      "Говоря простым языком, regex — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
1326
      "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
1327
      "Так что изучение regex рано или поздно пригодится.\n"
1328
     ]
1329
    }
1330
   ],
1331
   "source": [
1332
    "print(re.sub(r'регулярн[а-я]+ выражен[а-я]+', 'regex', text))"
1333
   ]
1334
  },
1335
  {
1336
   "cell_type": "markdown",
1337
   "metadata": {
1338
    "id": "gmOZp2v2Lk4f"
1339
   },
1340
   "source": [
1341
    "Функция `re.split(pattern, string)` – разделяет строку по заданному шаблону\n"
1342
   ]
1343
  },
1344
  {
1345
   "cell_type": "code",
1346
   "execution_count": null,
1347
   "metadata": {
1348
    "colab": {
1349
     "base_uri": "https://localhost:8080/"
1350
    },
1351
    "id": "TiaeuW0HLlMp",
1352
    "outputId": "33bd8c9d-833a-43fb-c31f-a50bb650ef02"
1353
   },
1354
   "outputs": [
1355
    {
1356
     "data": {
1357
      "text/plain": [
1358
       "['Столбец1', 'Столбец2', 'Столбец3', 'Столбец4', 'Столбец5']"
1359
      ]
1360
     },
1361
     "execution_count": 59,
1362
     "metadata": {},
1363
     "output_type": "execute_result"
1364
    }
1365
   ],
1366
   "source": [
1367
    "columns = 'Столбец1,Столбец2;Столбец3, Столбец4; Столбец5'\n",
1368
    "re.split(r'[,;]\\s?', columns)"
1369
   ]
1370
  },
1371
  {
1372
   "cell_type": "markdown",
1373
   "metadata": {
1374
    "id": "wdncyUbvwPD1"
1375
   },
1376
   "source": [
1377
    "Часть шаблона можно заключить в скобки (...). Это называется «скобочная группа».\n",
1378
    "Это позволяет:  \n",
1379
    "- поместить часть шаблона в отдельную структуру (группу);\n",
1380
    "- если установить квантификатор после скобок, то он будет применяться ко всему содержимому скобки, а не к одному символу.\n",
1381
    "\n",
1382
    "При наличии подгрупп в шаблоне можно ссылаться на них через их порядковый номер при помощи \\1, \\2, \\3, …  \n",
1383
    "\n",
1384
    "Группам можно давать собственные имена при помощи (?P<имя>...)"
1385
   ]
1386
  },
1387
  {
1388
   "cell_type": "markdown",
1389
   "metadata": {
1390
    "id": "_5UjJOdNwPD1"
1391
   },
1392
   "source": [
1393
    "Выделим группы символов из посадочного талона, где:\n",
1394
    "- первые 2 символа - это авиакомпания;\n",
1395
    "- 4 следующие символа - номер рейса;\n",
1396
    "- 3 следующих символа - аэропорт отправления;\n",
1397
    "- 3 следюущих - аэропорт прибытия;\n",
1398
    "- оставшиеся - дата рейса.\n",
1399
    "\n",
1400
    "Предполагаем, что все буквы всегда в верхнем регистре"
1401
   ]
1402
  },
1403
  {
1404
   "cell_type": "code",
1405
   "execution_count": null,
1406
   "metadata": {
1407
    "id": "tXhYp4PywPD2"
1408
   },
1409
   "outputs": [],
1410
   "source": [
1411
    "flight = \"\"\"\n",
1412
    "Boarding pass: LA4214 AER-CDB 06NOV\n",
1413
    "Boarding pass: LA4215 AER-CDB 07NOV\n",
1414
    "\"\"\""
1415
   ]
1416
  },
1417
  {
1418
   "cell_type": "markdown",
1419
   "metadata": {
1420
    "id": "Nh5fzDHF0qvT"
1421
   },
1422
   "source": [
1423
    "Функция `re.search(pattern, string)` – ищет шаблон по всей строке, но только первое вхождение. Возвращает match-объект"
1424
   ]
1425
  },
1426
  {
1427
   "cell_type": "code",
1428
   "execution_count": null,
1429
   "metadata": {
1430
    "colab": {
1431
     "base_uri": "https://localhost:8080/"
1432
    },
1433
    "id": "EOXGsViMwPD2",
1434
    "outputId": "a759da01-139a-4660-abb2-590adf4f186f"
1435
   },
1436
   "outputs": [
1437
    {
1438
     "name": "stdout",
1439
     "output_type": "stream",
1440
     "text": [
1441
      "LA4214 AER-CDB 06NOV\n"
1442
     ]
1443
    }
1444
   ],
1445
   "source": [
1446
    "regex_flight = r'([A-Z]{2})(\\d{4})\\s([A-Z]{3})-([A-Z]{3})\\s(\\d{2}[A-Z]{3})'\n",
1447
    "\n",
1448
    "flight_match_result = re.search(regex_flight, flight)\n",
1449
    "# print(flight_match_result)\n",
1450
    "print(flight_match_result.group(1))\n",
1451
    "# print(flight_match_result.start())\n",
1452
    "# print(flight_match_result.end())"
1453
   ]
1454
  },
1455
  {
1456
   "cell_type": "markdown",
1457
   "metadata": {
1458
    "id": "siGiRo7R30m4"
1459
   },
1460
   "source": [
1461
    "А как отработает findall?"
1462
   ]
1463
  },
1464
  {
1465
   "cell_type": "code",
1466
   "execution_count": null,
1467
   "metadata": {
1468
    "colab": {
1469
     "base_uri": "https://localhost:8080/"
1470
    },
1471
    "id": "3ty5aQva32uy",
1472
    "outputId": "e582236b-12b9-4887-ad21-2c5763dab34b"
1473
   },
1474
   "outputs": [
1475
    {
1476
     "name": "stdout",
1477
     "output_type": "stream",
1478
     "text": [
1479
      "[('LA', '4214', 'AER', 'CDB', '06NOV'), ('LA', '4215', 'AER', 'CDB', '07NOV')]\n"
1480
     ]
1481
    }
1482
   ],
1483
   "source": [
1484
    "regex_flight = r'([A-Z]{2})(\\d{4})\\s([A-Z]{3})-([A-Z]{3})\\s(\\d{2}[A-Z]{3})'\n",
1485
    "\n",
1486
    "flight_match_result = re.findall(regex_flight, flight)\n",
1487
    "print(flight_match_result)"
1488
   ]
1489
  },
1490
  {
1491
   "cell_type": "markdown",
1492
   "metadata": {
1493
    "id": "H3_UNBKLewqf"
1494
   },
1495
   "source": [
1496
    "Посчитаем количество лайков/репостов"
1497
   ]
1498
  },
1499
  {
1500
   "cell_type": "code",
1501
   "execution_count": null,
1502
   "metadata": {
1503
    "id": "RBGewGNf_hzY"
1504
   },
1505
   "outputs": [],
1506
   "source": [
1507
    "messages = ['Опять дождь! Лайков: 2', 'Крутой был концерт 21 августа! Лайков: 28, Репостов: 22']"
1508
   ]
1509
  },
1510
  {
1511
   "cell_type": "code",
1512
   "execution_count": null,
1513
   "metadata": {
1514
    "colab": {
1515
     "base_uri": "https://localhost:8080/"
1516
    },
1517
    "id": "gQfec0rL_hzY",
1518
    "outputId": "421afe6b-d0eb-40db-df62-1bf11bd0b07a"
1519
   },
1520
   "outputs": [
1521
    {
1522
     "name": "stdout",
1523
     "output_type": "stream",
1524
     "text": [
1525
      "<re.Match object; span=(13, 22), match='Лайков: 2'>\n",
1526
      "None\n",
1527
      "<re.Match object; span=(31, 41), match='Лайков: 28'>\n",
1528
      "<re.Match object; span=(43, 55), match='Репостов: 22'>\n",
1529
      "30\n",
1530
      "22\n"
1531
     ]
1532
    }
1533
   ],
1534
   "source": [
1535
    "likes = 0\n",
1536
    "reposts = 0\n",
1537
    "for msg in messages:\n",
1538
    "    likes_pattern = re.search(r'Лайков:\\s(\\d+)', msg)\n",
1539
    "    print(likes_pattern)\n",
1540
    "    repost_pattern = re.search(r'Репостов:\\s(\\d+)', msg)\n",
1541
    "    print(repost_pattern)\n",
1542
    "\n",
1543
    "    if likes_pattern: likes += int(likes_pattern.group(1))\n",
1544
    "    if repost_pattern: reposts += int(repost_pattern.group(1))\n",
1545
    "\n",
1546
    "print(likes)\n",
1547
    "print(reposts)"
1548
   ]
1549
  },
1550
  {
1551
   "cell_type": "markdown",
1552
   "metadata": {
1553
    "id": "NyU0lIob3JDE"
1554
   },
1555
   "source": [
1556
    "Функция `re.match(pattern, string)` – ищет по заданному шаблону в начале строки. Возвращает match-объект"
1557
   ]
1558
  },
1559
  {
1560
   "cell_type": "markdown",
1561
   "metadata": {
1562
    "id": "3j5nDFB13bQ4"
1563
   },
1564
   "source": [
1565
    "Как нам найти все изображения в потенциально огромном списке файлов буквально в пару строк кода? За изображения будем считать файлы с расширениями jpg, png и gif.\n",
1566
    "\n",
1567
    "Для каждого подходящего файла будем выводить фразу \n",
1568
    "`Изображение найдено: название файла`, \n",
1569
    "а если файл не подходит, то `\"Название файла\" не является изображением`."
1570
   ]
1571
  },
1572
  {
1573
   "cell_type": "code",
1574
   "execution_count": null,
1575
   "metadata": {
1576
    "id": "sDnzyZU_3h6h"
1577
   },
1578
   "outputs": [],
1579
   "source": [
1580
    "file_name_list = ['my.profile', 'conspect.doc', 'my_photo.jpg', 'error-jpg', 'img0912.png', 'index.html', 'favicon.gif', 'img_copy.jpg.tmp']"
1581
   ]
1582
  },
1583
  {
1584
   "cell_type": "code",
1585
   "execution_count": null,
1586
   "metadata": {
1587
    "colab": {
1588
     "base_uri": "https://localhost:8080/"
1589
    },
1590
    "id": "mTIzYuG_3jOH",
1591
    "outputId": "276d5478-a027-4ba5-c76f-eec63174ace6"
1592
   },
1593
   "outputs": [
1594
    {
1595
     "name": "stdout",
1596
     "output_type": "stream",
1597
     "text": [
1598
      "my.profile не является изображением\n",
1599
      "conspect.doc не является изображением\n",
1600
      "Изображение найдено: my_photo.jpg\n",
1601
      "error-jpg не является изображением\n",
1602
      "Изображение найдено: img0912.png\n",
1603
      "index.html не является изображением\n",
1604
      "Изображение найдено: favicon.gif\n",
1605
      "img_copy.jpg.tmp не является изображением\n"
1606
     ]
1607
    }
1608
   ],
1609
   "source": [
1610
    "for file_ in file_name_list:\n",
1611
    "    pattern = r'\\w+\\.(jpg|png|gif)$'\n",
1612
    "    if re.match(pattern, file_):\n",
1613
    "        print(f'Изображение найдено: {file_}')\n",
1614
    "    else:\n",
1615
    "        print(f'{file_} не является изображением')"
1616
   ]
1617
  },
1618
  {
1619
   "cell_type": "markdown",
1620
   "metadata": {
1621
    "id": "0G3QrUxLwPD2"
1622
   },
1623
   "source": [
1624
    "Переведем даты к другому формату при помощи групп"
1625
   ]
1626
  },
1627
  {
1628
   "cell_type": "code",
1629
   "execution_count": null,
1630
   "metadata": {
1631
    "colab": {
1632
     "base_uri": "https://localhost:8080/",
1633
     "height": 36
1634
    },
1635
    "id": "AoOarZ8rwPD2",
1636
    "outputId": "a222541b-03ad-4976-e002-a96e65ed0e2f"
1637
   },
1638
   "outputs": [
1639
    {
1640
     "data": {
1641
      "application/vnd.google.colaboratory.intrinsic+json": {
1642
       "type": "string"
1643
      },
1644
      "text/plain": [
1645
       "'some text 30.08.1991 some text'"
1646
      ]
1647
     },
1648
     "execution_count": 75,
1649
     "metadata": {},
1650
     "output_type": "execute_result"
1651
    }
1652
   ],
1653
   "source": [
1654
    "date = 'some text 08/30/1991 some text '\n",
1655
    "re.sub(r'(\\d\\d)/(\\d\\d)/(\\d{4})', r'\\2.\\1.\\3', date)"
1656
   ]
1657
  },
1658
  {
1659
   "cell_type": "markdown",
1660
   "metadata": {
1661
    "id": "HsjnmSHn_ehw"
1662
   },
1663
   "source": [
1664
    "Удалим все последовательные повторы слов из текста"
1665
   ]
1666
  },
1667
  {
1668
   "cell_type": "code",
1669
   "execution_count": null,
1670
   "metadata": {
1671
    "id": "kA1FpojA_h5k"
1672
   },
1673
   "outputs": [],
1674
   "source": [
1675
    "some_string = 'Напишите код, который будет будет будет будет удалять все все все все последовательные повторы слов из из из из заданной строки строки при помощи регулярных выражений.'"
1676
   ]
1677
  },
1678
  {
1679
   "cell_type": "code",
1680
   "execution_count": null,
1681
   "metadata": {
1682
    "colab": {
1683
     "base_uri": "https://localhost:8080/",
1684
     "height": 36
1685
    },
1686
    "id": "l5m2unv5AKoE",
1687
    "outputId": "342fa4b3-cc1a-412a-fd3f-5442bf2c2d23"
1688
   },
1689
   "outputs": [
1690
    {
1691
     "data": {
1692
      "application/vnd.google.colaboratory.intrinsic+json": {
1693
       "type": "string"
1694
      },
1695
      "text/plain": [
1696
       "'Напишите код, который будет удалять все последовательные повторы слов из заданной строки при помощи регулярных выражений.'"
1697
      ]
1698
     },
1699
     "execution_count": 77,
1700
     "metadata": {},
1701
     "output_type": "execute_result"
1702
    }
1703
   ],
1704
   "source": [
1705
    "re.sub(r'(\\w+)(\\s\\1)+', r'\\1', some_string)"
1706
   ]
1707
  },
1708
  {
1709
   "cell_type": "markdown",
1710
   "metadata": {
1711
    "id": "pPe1N0HawPD3"
1712
   },
1713
   "source": [
1714
    "[Документация по регулярным выражениям](https://docs.python.org/3/library/re.html)  \n",
1715
    "[Тестер регулярных выражений](https://regex101.com/)  \n",
1716
    "https://ihateregex.io  \n",
1717
    "https://regexcrossword.com/howtoplay"
1718
   ]
1719
  },
1720
  {
1721
   "cell_type": "markdown",
1722
   "metadata": {
1723
    "id": "4bInRY3OHWNB"
1724
   },
1725
   "source": [
1726
    "Регулярные\n",
1727
    "выражения\n",
1728
    "Сборник рецептов\n",
1729
    "2015\n",
1730
    "Ян Гойвертс,\n",
1731
    "Стивен\n",
1732
    "Левитан"
1733
   ]
1734
  }
1735
 ],
1736
 "metadata": {
1737
  "colab": {
1738
   "provenance": []
1739
  },
1740
  "kernelspec": {
1741
   "display_name": "Python 3 (ipykernel)",
1742
   "language": "python",
1743
   "name": "python3"
1744
  },
1745
  "language_info": {
1746
   "codemirror_mode": {
1747
    "name": "ipython",
1748
    "version": 3
1749
   },
1750
   "file_extension": ".py",
1751
   "mimetype": "text/x-python",
1752
   "name": "python",
1753
   "nbconvert_exporter": "python",
1754
   "pygments_lexer": "ipython3",
1755
   "version": "3.9.13"
1756
  }
1757
 },
1758
 "nbformat": 4,
1759
 "nbformat_minor": 1
1760
}
1761

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.