python_for_analytics

1
{
2
 "cells": [
3
  {
4
   "cell_type": "markdown",
5
   "metadata": {},
6
   "source": [
7
    "# Работа с файлами\n",
8
    "- Обработать первые N строк файла\n",
9
    "- Прочитать файл из другой папки\n",
10
    "- Пример группировки большого файла cards.csv\n",
11
    "- Формат JSON\n",
12
    "- Кодировки файлов ([статья 1](https://tproger.ru/translations/unicode-and-encoding-python-guide/) и [статья 2](https://pythononline.ru/osnovy/encode-decode))"
13
   ]
14
  },
15
  {
16
   "cell_type": "markdown",
17
   "metadata": {},
18
   "source": [
19
    "### Работа с Экселем в питоне\n",
20
    "https://openpyxl.readthedocs.io/en/stable/"
21
   ]
22
  },
23
  {
24
   "cell_type": "markdown",
25
   "metadata": {},
26
   "source": [
27
    "# Когда файл лежит где-то"
28
   ]
29
  },
30
  {
31
   "cell_type": "code",
32
   "execution_count": null,
33
   "metadata": {},
34
   "outputs": [],
35
   "source": [
36
    "# вариант 1 - файл лежит рядом с кодом\n",
37
    "f = open('cards.csv')"
38
   ]
39
  },
40
  {
41
   "cell_type": "code",
42
   "execution_count": null,
43
   "metadata": {},
44
   "outputs": [],
45
   "source": [
46
    "# вариант 2 - файл лежит во вложенной папке рядом с кодом\n",
47
    "\n",
48
    "f = open('logs/hostlogs_part_5283.csv')"
49
   ]
50
  },
51
  {
52
   "cell_type": "code",
53
   "execution_count": 2,
54
   "metadata": {},
55
   "outputs": [],
56
   "source": [
57
    "# вариант 3 - файл лежит в произвольной папке где-то на компе\n",
58
    "\n",
59
    "# Mac, Linux, Ubuntu, FreeBSD, CentOS\n",
60
    "f = open('/Users/kbashevoy/Desktop/Нетология/Занятия/Занятие 5/logs/hostlogs_part_5284.csv')"
61
   ]
62
  },
63
  {
64
   "cell_type": "code",
65
   "execution_count": 3,
66
   "metadata": {},
67
   "outputs": [
68
    {
69
     "data": {
70
      "text/plain": [
71
       "'очень длинный текст'"
72
      ]
73
     },
74
     "execution_count": 3,
75
     "metadata": {},
76
     "output_type": "execute_result"
77
    }
78
   ],
79
   "source": [
80
    "text = 'очень длинный \\\n",
81
    "текст'\n",
82
    "\n",
83
    "text"
84
   ]
85
  },
86
  {
87
   "cell_type": "code",
88
   "execution_count": 4,
89
   "metadata": {},
90
   "outputs": [
91
    {
92
     "data": {
93
      "text/plain": [
94
       "'C:\\\\Users\\\\kbashevoy\\\\data.csv'"
95
      ]
96
     },
97
     "execution_count": 4,
98
     "metadata": {},
99
     "output_type": "execute_result"
100
    }
101
   ],
102
   "source": [
103
    "'C:\\\\Users\\\\kbashevoy\\\\data.csv'"
104
   ]
105
  },
106
  {
107
   "cell_type": "code",
108
   "execution_count": 7,
109
   "metadata": {},
110
   "outputs": [
111
    {
112
     "data": {
113
      "text/plain": [
114
       "\"select * from table where date='2023-01-23'\""
115
      ]
116
     },
117
     "execution_count": 7,
118
     "metadata": {},
119
     "output_type": "execute_result"
120
    }
121
   ],
122
   "source": [
123
    "'select * from table where date=\\'2023-01-23\\''"
124
   ]
125
  },
126
  {
127
   "cell_type": "code",
128
   "execution_count": null,
129
   "metadata": {},
130
   "outputs": [],
131
   "source": [
132
    "# Windows\n",
133
    "\n",
134
    "# 1 выход - экранирование - подсказка питону, что следующий символ это просто символ\n",
135
    "# символ экранирования - это тоже \\\n",
136
    "f = open('C:\\\\Users\\\\kbashevoy\\\\data.csv')\n",
137
    "\n",
138
    "# 2 выход - опция r\n",
139
    "f = open(r'C:\\Users\\kbashevoy\\data.csv')"
140
   ]
141
  },
142
  {
143
   "cell_type": "code",
144
   "execution_count": null,
145
   "metadata": {},
146
   "outputs": [],
147
   "source": [
148
    "import os"
149
   ]
150
  },
151
  {
152
   "cell_type": "code",
153
   "execution_count": null,
154
   "metadata": {},
155
   "outputs": [],
156
   "source": [
157
    "os.path.join('folder', 'data.csv')  # будет работать в любой ОС"
158
   ]
159
  },
160
  {
161
   "cell_type": "code",
162
   "execution_count": null,
163
   "metadata": {},
164
   "outputs": [],
165
   "source": [
166
    "open('folder/data.csv')"
167
   ]
168
  },
169
  {
170
   "cell_type": "markdown",
171
   "metadata": {},
172
   "source": [
173
    "# Чтение файлов построчно и группировка\n",
174
    "- Читать файл целиком (текстовые редакторы/Эксель)\n",
175
    "- Построчное чтение - расход оперативной памяти обычно близок к 0"
176
   ]
177
  },
178
  {
179
   "cell_type": "code",
180
   "execution_count": null,
181
   "metadata": {},
182
   "outputs": [],
183
   "source": [
184
    "f = open('cards.csv')\n",
185
    "\n",
186
    "f.close()"
187
   ]
188
  },
189
  {
190
   "cell_type": "code",
191
   "execution_count": 19,
192
   "metadata": {},
193
   "outputs": [
194
    {
195
     "data": {
196
      "text/plain": [
197
       "{'червы': 3, 'бубны': 0}"
198
      ]
199
     },
200
     "execution_count": 19,
201
     "metadata": {},
202
     "output_type": "execute_result"
203
    }
204
   ],
205
   "source": [
206
    "stats = {'червы': 3}  # {'червы': 3, 'пики': 1, 'бубны': 1}\n",
207
    "\n",
208
    "stats.setdefault('червы', 0)\n",
209
    "stats.setdefault('бубны', 0)\n",
210
    "stats"
211
   ]
212
  },
213
  {
214
   "cell_type": "code",
215
   "execution_count": 24,
216
   "metadata": {},
217
   "outputs": [
218
    {
219
     "name": "stdout",
220
     "output_type": "stream",
221
     "text": [
222
      "0 червы\n",
223
      "1 пики\n",
224
      "2 червы\n",
225
      "3 бубны\n",
226
      "4 червы\n",
227
      "5 пики\n",
228
      "6 трефы\n"
229
     ]
230
    },
231
    {
232
     "data": {
233
      "text/plain": [
234
       "{'червы': 3, 'пики': 2, 'бубны': 1, 'трефы': 1}"
235
      ]
236
     },
237
     "execution_count": 24,
238
     "metadata": {},
239
     "output_type": "execute_result"
240
    }
241
   ],
242
   "source": [
243
    "stats = {}\n",
244
    "\n",
245
    "with open('cards.csv') as f:\n",
246
    "    # content = f.readlines()  # получаем список - это НЕ построчное чтение\n",
247
    "    \n",
248
    "    for i, line in enumerate(f):  # построчное чтение\n",
249
    "        line = line.strip().split(',')\n",
250
    "        \n",
251
    "        suit, _ = line  # если в списке line точно два значения\n",
252
    "        # suit = line[0]\n",
253
    "        # value = line[1]\n",
254
    "        \n",
255
    "        print(i, suit)\n",
256
    "        \n",
257
    "        stats.setdefault(suit, 0)\n",
258
    "        stats[suit] += 1\n",
259
    "#         if suit in stats:\n",
260
    "#             stats[suit] += 1\n",
261
    "#         else:\n",
262
    "#             stats[suit] = 1\n",
263
    "        \n",
264
    "        if i > 5:\n",
265
    "            break\n",
266
    "            \n",
267
    "stats"
268
   ]
269
  },
270
  {
271
   "cell_type": "code",
272
   "execution_count": 28,
273
   "metadata": {},
274
   "outputs": [
275
    {
276
     "data": {
277
      "text/plain": [
278
       "['червы', 'пики', 'червы', 'бубны', 'червы']"
279
      ]
280
     },
281
     "execution_count": 28,
282
     "metadata": {},
283
     "output_type": "execute_result"
284
    }
285
   ],
286
   "source": [
287
    "f = open('cards.csv')\n",
288
    "\n",
289
    "suits_list = [x.strip().split(',')[0] for x in f]\n",
290
    "suits_list[:5]"
291
   ]
292
  },
293
  {
294
   "cell_type": "code",
295
   "execution_count": 29,
296
   "metadata": {},
297
   "outputs": [],
298
   "source": [
299
    "from collections import Counter"
300
   ]
301
  },
302
  {
303
   "cell_type": "code",
304
   "execution_count": 30,
305
   "metadata": {},
306
   "outputs": [
307
    {
308
     "data": {
309
      "text/plain": [
310
       "Counter({'червы': 25020, 'пики': 24934, 'бубны': 24932, 'трефы': 25114})"
311
      ]
312
     },
313
     "execution_count": 30,
314
     "metadata": {},
315
     "output_type": "execute_result"
316
    }
317
   ],
318
   "source": [
319
    "Counter(suits_list)"
320
   ]
321
  },
322
  {
323
   "cell_type": "code",
324
   "execution_count": 31,
325
   "metadata": {},
326
   "outputs": [],
327
   "source": [
328
    "import pandas as pd"
329
   ]
330
  },
331
  {
332
   "cell_type": "code",
333
   "execution_count": 34,
334
   "metadata": {},
335
   "outputs": [
336
    {
337
     "data": {
338
      "text/plain": [
339
       "трефы    25114\n",
340
       "червы    25020\n",
341
       "пики     24934\n",
342
       "бубны    24932\n",
343
       "Name: suit, dtype: int64"
344
      ]
345
     },
346
     "execution_count": 34,
347
     "metadata": {},
348
     "output_type": "execute_result"
349
    }
350
   ],
351
   "source": [
352
    "pd.read_csv('cards.csv', names=['suit', 'value'])['suit'].value_counts()"
353
   ]
354
  },
355
  {
356
   "cell_type": "markdown",
357
   "metadata": {},
358
   "source": [
359
    "# Кодировки\n",
360
    "1. Указать кодировку при открытии / записи в файл\n",
361
    "```python\n",
362
    "open('data.csv', mode='w', encoding='utf-8')  # Windows-1251 --> encoding='cp1251'\n",
363
    "```\n",
364
    "2. Текстовый редактор открывает ваш результат криво.\n",
365
    "3. Эксель\n",
366
    "4. Русские буквы в составе списков и словарей."
367
   ]
368
  },
369
  {
370
   "cell_type": "code",
371
   "execution_count": 37,
372
   "metadata": {},
373
   "outputs": [],
374
   "source": [
375
    "data = ['Москва', 'Питер']"
376
   ]
377
  },
378
  {
379
   "cell_type": "code",
380
   "execution_count": 38,
381
   "metadata": {},
382
   "outputs": [],
383
   "source": [
384
    "import json"
385
   ]
386
  },
387
  {
388
   "cell_type": "code",
389
   "execution_count": 40,
390
   "metadata": {},
391
   "outputs": [
392
    {
393
     "data": {
394
      "text/plain": [
395
       "'[\"Москва\", \"Питер\"]'"
396
      ]
397
     },
398
     "execution_count": 40,
399
     "metadata": {},
400
     "output_type": "execute_result"
401
    }
402
   ],
403
   "source": [
404
    "json.dumps(data, ensure_ascii=False)"
405
   ]
406
  },
407
  {
408
   "cell_type": "code",
409
   "execution_count": null,
410
   "metadata": {},
411
   "outputs": [],
412
   "source": [
413
    "0010010101010100101"
414
   ]
415
  },
416
  {
417
   "cell_type": "code",
418
   "execution_count": 35,
419
   "metadata": {},
420
   "outputs": [
421
    {
422
     "data": {
423
      "text/plain": [
424
       "65"
425
      ]
426
     },
427
     "execution_count": 35,
428
     "metadata": {},
429
     "output_type": "execute_result"
430
    }
431
   ],
432
   "source": [
433
    "# ASCII\n",
434
    "\n",
435
    "ord('A')"
436
   ]
437
  },
438
  {
439
   "cell_type": "code",
440
   "execution_count": 36,
441
   "metadata": {},
442
   "outputs": [
443
    {
444
     "data": {
445
      "text/plain": [
446
       "'A'"
447
      ]
448
     },
449
     "execution_count": 36,
450
     "metadata": {},
451
     "output_type": "execute_result"
452
    }
453
   ],
454
   "source": [
455
    "chr(65)"
456
   ]
457
  },
458
  {
459
   "cell_type": "markdown",
460
   "metadata": {},
461
   "source": [
462
    "UNICODE"
463
   ]
464
  },
465
  {
466
   "cell_type": "code",
467
   "execution_count": null,
468
   "metadata": {},
469
   "outputs": [],
470
   "source": []
471
  },
472
  {
473
   "cell_type": "code",
474
   "execution_count": null,
475
   "metadata": {},
476
   "outputs": [],
477
   "source": []
478
  },
479
  {
480
   "cell_type": "code",
481
   "execution_count": null,
482
   "metadata": {},
483
   "outputs": [],
484
   "source": []
485
  },
486
  {
487
   "cell_type": "markdown",
488
   "metadata": {},
489
   "source": [
490
    "Опции при открытии файлов:\n",
491
    "- 'r' открыть для чтения. Файл при этом не меняется\n",
492
    "- 'w' открыть файл для записи. Файл при этом полностью чистится (!)\n",
493
    "- 'a' открыть файл для добавления. Файл не меняется, все записи добавляются в конец"
494
   ]
495
  },
496
  {
497
   "cell_type": "code",
498
   "execution_count": null,
499
   "metadata": {},
500
   "outputs": [],
501
   "source": [
502
    "# открываем файл для чтения (опция r)\n",
503
    "f = open('visit_log.csv', 'r')"
504
   ]
505
  },
506
  {
507
   "cell_type": "code",
508
   "execution_count": null,
509
   "metadata": {},
510
   "outputs": [],
511
   "source": []
512
  },
513
  {
514
   "cell_type": "code",
515
   "execution_count": null,
516
   "metadata": {},
517
   "outputs": [],
518
   "source": []
519
  },
520
  {
521
   "cell_type": "code",
522
   "execution_count": null,
523
   "metadata": {},
524
   "outputs": [],
525
   "source": []
526
  },
527
  {
528
   "cell_type": "code",
529
   "execution_count": null,
530
   "metadata": {
531
    "scrolled": true
532
   },
533
   "outputs": [],
534
   "source": [
535
    "# прочитать первую строчку\n",
536
    "f.readline()"
537
   ]
538
  },
539
  {
540
   "cell_type": "code",
541
   "execution_count": null,
542
   "metadata": {},
543
   "outputs": [],
544
   "source": [
545
    "# прочитать еще одну\n",
546
    "f.readline()"
547
   ]
548
  },
549
  {
550
   "cell_type": "code",
551
   "execution_count": null,
552
   "metadata": {},
553
   "outputs": [],
554
   "source": [
555
    "# можно и так\n",
556
    "next(f)"
557
   ]
558
  },
559
  {
560
   "cell_type": "code",
561
   "execution_count": null,
562
   "metadata": {},
563
   "outputs": [],
564
   "source": [
565
    "# прочитать все содержимое файла в переменную content\n",
566
    "content = f.readlines()"
567
   ]
568
  },
569
  {
570
   "cell_type": "code",
571
   "execution_count": null,
572
   "metadata": {},
573
   "outputs": [],
574
   "source": [
575
    "content[:5]"
576
   ]
577
  },
578
  {
579
   "cell_type": "code",
580
   "execution_count": null,
581
   "metadata": {},
582
   "outputs": [],
583
   "source": [
584
    "# построчное чтение файла\n",
585
    "for line in f:\n",
586
    "    print(line)\n",
587
    "    \n",
588
    "    break"
589
   ]
590
  },
591
  {
592
   "cell_type": "markdown",
593
   "metadata": {},
594
   "source": [
595
    "Часто используется конструкция \n",
596
    "```python\n",
597
    "another_line.strip().split(',')\n",
598
    "```"
599
   ]
600
  },
601
  {
602
   "cell_type": "code",
603
   "execution_count": null,
604
   "metadata": {},
605
   "outputs": [],
606
   "source": [
607
    "another_line = f.readline()\n",
608
    "another_line"
609
   ]
610
  },
611
  {
612
   "cell_type": "code",
613
   "execution_count": null,
614
   "metadata": {},
615
   "outputs": [],
616
   "source": [
617
    "# удаляем перенос строки и лишние пробелы\n",
618
    "another_line.strip()"
619
   ]
620
  },
621
  {
622
   "cell_type": "code",
623
   "execution_count": null,
624
   "metadata": {},
625
   "outputs": [],
626
   "source": [
627
    "# разбиваем столбцы\n",
628
    "another_line.strip().split(',')"
629
   ]
630
  },
631
  {
632
   "cell_type": "code",
633
   "execution_count": null,
634
   "metadata": {},
635
   "outputs": [],
636
   "source": [
637
    "# закрытие файла\n",
638
    "f.close()"
639
   ]
640
  },
641
  {
642
   "cell_type": "code",
643
   "execution_count": null,
644
   "metadata": {},
645
   "outputs": [],
646
   "source": [
647
    "# после закрытия не получится прочитать\n",
648
    "f.readline()"
649
   ]
650
  },
651
  {
652
   "cell_type": "code",
653
   "execution_count": null,
654
   "metadata": {},
655
   "outputs": [],
656
   "source": [
657
    "# прочитать все строчки файла в список (т. е. в оперативную память)\n",
658
    "f = open('visit_log.csv', 'r')\n",
659
    "\n",
660
    "content = f.readlines()\n",
661
    "\n",
662
    "f.close()"
663
   ]
664
  },
665
  {
666
   "cell_type": "code",
667
   "execution_count": null,
668
   "metadata": {},
669
   "outputs": [],
670
   "source": [
671
    "content[:5]"
672
   ]
673
  },
674
  {
675
   "cell_type": "code",
676
   "execution_count": null,
677
   "metadata": {},
678
   "outputs": [],
679
   "source": []
680
  },
681
  {
682
   "cell_type": "code",
683
   "execution_count": null,
684
   "metadata": {},
685
   "outputs": [],
686
   "source": [
687
    "f = open('results.csv', 'w')"
688
   ]
689
  },
690
  {
691
   "cell_type": "code",
692
   "execution_count": null,
693
   "metadata": {},
694
   "outputs": [],
695
   "source": [
696
    "f.write('Начинаю запись первой строки...\\n')"
697
   ]
698
  },
699
  {
700
   "cell_type": "code",
701
   "execution_count": null,
702
   "metadata": {},
703
   "outputs": [],
704
   "source": [
705
    "f.write('Начинаю запись второй строки...\\n')"
706
   ]
707
  },
708
  {
709
   "cell_type": "markdown",
710
   "metadata": {},
711
   "source": [
712
    "Здесь кто-то еще хочет в него записать"
713
   ]
714
  },
715
  {
716
   "cell_type": "code",
717
   "execution_count": null,
718
   "metadata": {},
719
   "outputs": [],
720
   "source": [
721
    "my_friend_results = open('results.csv', 'w')"
722
   ]
723
  },
724
  {
725
   "cell_type": "code",
726
   "execution_count": null,
727
   "metadata": {},
728
   "outputs": [],
729
   "source": [
730
    "my_friend_results.write('Тут еще результаты есть')"
731
   ]
732
  },
733
  {
734
   "cell_type": "code",
735
   "execution_count": null,
736
   "metadata": {},
737
   "outputs": [],
738
   "source": [
739
    "# пишем свой результат\n",
740
    "f.close()"
741
   ]
742
  },
743
  {
744
   "cell_type": "code",
745
   "execution_count": null,
746
   "metadata": {},
747
   "outputs": [],
748
   "source": [
749
    "# и наш результат перезатирается\n",
750
    "my_friend_results.close()"
751
   ]
752
  },
753
  {
754
   "cell_type": "markdown",
755
   "metadata": {},
756
   "source": [
757
    "### Контекстный менеджер\n",
758
    "Как обезопасить себя от подобных накладок"
759
   ]
760
  },
761
  {
762
   "cell_type": "code",
763
   "execution_count": null,
764
   "metadata": {},
765
   "outputs": [],
766
   "source": [
767
    "with open('results.csv', 'w') as f:\n",
768
    "    f.write('Начинаю запись первой строки...\\n')\n",
769
    "    f.write('Начинаю запись второй строки...\\n')\n",
770
    "    \n",
771
    "    my_friend_results = open('results.csv', 'w')\n",
772
    "    my_friend_results.write('Тут еще результаты есть')\n",
773
    "    my_friend_results.close()"
774
   ]
775
  },
776
  {
777
   "cell_type": "markdown",
778
   "metadata": {},
779
   "source": [
780
    "### А можно читать и сразу в файл записывать?\n",
781
    "Напишите функцию, которая фильтрует файл visit_log.csv по источнику context и пишет результат в visits_context.csv. Используйте функцию из второго упражнения для проверки результата."
782
   ]
783
  },
784
  {
785
   "cell_type": "code",
786
   "execution_count": null,
787
   "metadata": {},
788
   "outputs": [],
789
   "source": []
790
  },
791
  {
792
   "cell_type": "code",
793
   "execution_count": null,
794
   "metadata": {},
795
   "outputs": [],
796
   "source": []
797
  },
798
  {
799
   "cell_type": "code",
800
   "execution_count": null,
801
   "metadata": {},
802
   "outputs": [],
803
   "source": []
804
  },
805
  {
806
   "cell_type": "markdown",
807
   "metadata": {},
808
   "source": [
809
    "# Чтение списков и словарей из файла\n",
810
    "Смотрим что в файле purchase_log.txt. Похоже тут не строки, а словари"
811
   ]
812
  },
813
  {
814
   "cell_type": "code",
815
   "execution_count": null,
816
   "metadata": {},
817
   "outputs": [],
818
   "source": [
819
    "with open('purchase_log.txt') as f:\n",
820
    "    print([next(f) for x in range(5)])"
821
   ]
822
  },
823
  {
824
   "cell_type": "code",
825
   "execution_count": null,
826
   "metadata": {},
827
   "outputs": [],
828
   "source": [
829
    "import json"
830
   ]
831
  },
832
  {
833
   "cell_type": "code",
834
   "execution_count": null,
835
   "metadata": {},
836
   "outputs": [],
837
   "source": [
838
    "# перевод строки в словарь\n",
839
    "dict_in_string = '{\"a\": 1, \"b\": 2}'\n",
840
    "\n",
841
    "type(json.loads(dict_in_string))"
842
   ]
843
  },
844
  {
845
   "cell_type": "code",
846
   "execution_count": null,
847
   "metadata": {},
848
   "outputs": [],
849
   "source": [
850
    "# перевод строки в список\n",
851
    "list_in_string = '[1, 2, 3]'\n",
852
    "\n",
853
    "json.loads(list_in_string)[-1]"
854
   ]
855
  },
856
  {
857
   "cell_type": "code",
858
   "execution_count": null,
859
   "metadata": {},
860
   "outputs": [],
861
   "source": [
862
    "i = 0\n",
863
    "with open('purchase_log.txt') as f:\n",
864
    "    for line in f:\n",
865
    "        line = line.strip()\n",
866
    "        \n",
867
    "        dict_ = json.loads(line)\n",
868
    "        print(dict_, type(dict_))\n",
869
    "        \n",
870
    "        i += 1\n",
871
    "        if i > 5:\n",
872
    "            break"
873
   ]
874
  },
875
  {
876
   "cell_type": "markdown",
877
   "metadata": {},
878
   "source": [
879
    "### Из словаря в строку тоже можно"
880
   ]
881
  },
882
  {
883
   "cell_type": "code",
884
   "execution_count": null,
885
   "metadata": {},
886
   "outputs": [],
887
   "source": [
888
    "data = {'user_id': '1840e0b9d4', 'category': 'Продукты'}"
889
   ]
890
  },
891
  {
892
   "cell_type": "code",
893
   "execution_count": null,
894
   "metadata": {
895
    "scrolled": true
896
   },
897
   "outputs": [],
898
   "source": [
899
    "json.dumps(data)"
900
   ]
901
  },
902
  {
903
   "cell_type": "code",
904
   "execution_count": null,
905
   "metadata": {},
906
   "outputs": [],
907
   "source": [
908
    "type(json.dumps(data))"
909
   ]
910
  },
911
  {
912
   "cell_type": "markdown",
913
   "metadata": {},
914
   "source": [
915
    "# Модуль pickle\n",
916
    "Запись объекта сразу в файл как поток байтов"
917
   ]
918
  },
919
  {
920
   "cell_type": "code",
921
   "execution_count": null,
922
   "metadata": {},
923
   "outputs": [],
924
   "source": [
925
    "import pickle"
926
   ]
927
  },
928
  {
929
   "cell_type": "code",
930
   "execution_count": null,
931
   "metadata": {},
932
   "outputs": [],
933
   "source": [
934
    "data = {'user_id': '1840e0b9d4', 'category': 'Продукты'}"
935
   ]
936
  },
937
  {
938
   "cell_type": "code",
939
   "execution_count": null,
940
   "metadata": {},
941
   "outputs": [],
942
   "source": [
943
    "with open('data.pickle', 'wb') as f:\n",
944
    "    pickle.dump(data, f)"
945
   ]
946
  },
947
  {
948
   "cell_type": "code",
949
   "execution_count": null,
950
   "metadata": {},
951
   "outputs": [],
952
   "source": [
953
    "# прочитать объект из такого файла\n",
954
    "\n",
955
    "with open('data.pickle', 'rb') as f:\n",
956
    "    dict_ = pickle.load(f)\n",
957
    "    \n",
958
    "dict_, dict_['user_id']"
959
   ]
960
  },
961
  {
962
   "cell_type": "markdown",
963
   "metadata": {},
964
   "source": [
965
    "# Чтение файлов из папки"
966
   ]
967
  },
968
  {
969
   "cell_type": "code",
970
   "execution_count": null,
971
   "metadata": {},
972
   "outputs": [],
973
   "source": [
974
    "import os"
975
   ]
976
  },
977
  {
978
   "cell_type": "code",
979
   "execution_count": null,
980
   "metadata": {},
981
   "outputs": [],
982
   "source": [
983
    "# чтение файлов и папок\n",
984
    "for file in os.listdir('data'):\n",
985
    "    print(file)"
986
   ]
987
  },
988
  {
989
   "cell_type": "code",
990
   "execution_count": null,
991
   "metadata": {},
992
   "outputs": [],
993
   "source": [
994
    "# чтение всех файлов и папок, в том числе вложенных\n",
995
    "for root, directory, file in os.walk('data'):\n",
996
    "    print(root, directory, file)"
997
   ]
998
  },
999
  {
1000
   "cell_type": "markdown",
1001
   "metadata": {},
1002
   "source": [
1003
    "# Каталог пакетов pip (Python Package Index)\n",
1004
    "Варианты установки\n",
1005
    "1. С помощью Anaconda Navigator\n",
1006
    "2. В командной строке (Terminal на маке)\n",
1007
    "```bash\n",
1008
    "pip install package_name\n",
1009
    "```\n",
1010
    "3. Скачать версию с github и установить вручную\n",
1011
    "```bash\n",
1012
    "pip install .\n",
1013
    "```\n",
1014
    "\n",
1015
    "Пакеты устанавливаются в определенное окружение! Вам пригодится virtualenv"
1016
   ]
1017
  },
1018
  {
1019
   "cell_type": "code",
1020
   "execution_count": null,
1021
   "metadata": {},
1022
   "outputs": [],
1023
   "source": [
1024
    "!pip install pyyaml"
1025
   ]
1026
  },
1027
  {
1028
   "cell_type": "code",
1029
   "execution_count": null,
1030
   "metadata": {},
1031
   "outputs": [],
1032
   "source": [
1033
    "import plotly"
1034
   ]
1035
  },
1036
  {
1037
   "cell_type": "markdown",
1038
   "metadata": {},
1039
   "source": [
1040
    "# Простой импорт"
1041
   ]
1042
  },
1043
  {
1044
   "cell_type": "code",
1045
   "execution_count": null,
1046
   "metadata": {},
1047
   "outputs": [],
1048
   "source": [
1049
    "import sys\n",
1050
    "sys.path"
1051
   ]
1052
  },
1053
  {
1054
   "cell_type": "code",
1055
   "execution_count": null,
1056
   "metadata": {},
1057
   "outputs": [],
1058
   "source": [
1059
    "# добавляем в список библиотек папку libs\n",
1060
    "sys.path.append('libs')\n",
1061
    "sys.path"
1062
   ]
1063
  },
1064
  {
1065
   "cell_type": "code",
1066
   "execution_count": null,
1067
   "metadata": {},
1068
   "outputs": [],
1069
   "source": [
1070
    "from useful_codes import CATEGORIES"
1071
   ]
1072
  },
1073
  {
1074
   "cell_type": "code",
1075
   "execution_count": null,
1076
   "metadata": {},
1077
   "outputs": [],
1078
   "source": [
1079
    "CATEGORIES"
1080
   ]
1081
  },
1082
  {
1083
   "cell_type": "code",
1084
   "execution_count": null,
1085
   "metadata": {},
1086
   "outputs": [],
1087
   "source": [
1088
    "from useful_codes import word_count"
1089
   ]
1090
  },
1091
  {
1092
   "cell_type": "code",
1093
   "execution_count": null,
1094
   "metadata": {},
1095
   "outputs": [],
1096
   "source": [
1097
    "# посмотреть документацию функции\n",
1098
    "\n",
1099
    "?word_count"
1100
   ]
1101
  },
1102
  {
1103
   "cell_type": "code",
1104
   "execution_count": null,
1105
   "metadata": {},
1106
   "outputs": [],
1107
   "source": [
1108
    "word_count('Посчитай количество слов в тексте')"
1109
   ]
1110
  },
1111
  {
1112
   "cell_type": "markdown",
1113
   "metadata": {},
1114
   "source": [
1115
    "# Домашнее задание\n",
1116
    "1. Переведите содержимое файла purchase_log.txt в словарь purchases вида:\n",
1117
    "```python\n",
1118
    "{'1840e0b9d4': 'Продукты', ...}\n",
1119
    "```\n",
1120
    "\n",
1121
    "2. Для каждого user_id в файле visit_log.csv определите третий столбец с категорией покупки (если покупка была, сам файл visit_log.csv изменять не надо). Запишите в файл funnel.csv визиты из файла visit_log.csv, в которых были покупки с указанием категории.\n",
1122
    "\n",
1123
    "Учтите условия на данные:\n",
1124
    "- содержимое purchase_log.txt помещается в оперативную память компьютера\n",
1125
    "- содержимое visit_log.csv - нет; используйте только построчную обработку этого файла"
1126
   ]
1127
  },
1128
  {
1129
   "cell_type": "markdown",
1130
   "metadata": {},
1131
   "source": [
1132
    "Используйте метод json.loads()"
1133
   ]
1134
  },
1135
  {
1136
   "cell_type": "code",
1137
   "execution_count": 41,
1138
   "metadata": {},
1139
   "outputs": [
1140
    {
1141
     "data": {
1142
      "text/plain": [
1143
       "20000000000"
1144
      ]
1145
     },
1146
     "execution_count": 41,
1147
     "metadata": {},
1148
     "output_type": "execute_result"
1149
    }
1150
   ],
1151
   "source": [
1152
    "200000 * 100000"
1153
   ]
1154
  },
1155
  {
1156
   "cell_type": "code",
1157
   "execution_count": null,
1158
   "metadata": {},
1159
   "outputs": [],
1160
   "source": [
1161
    "for line in visit_log:\n",
1162
    "    if user_id in purchases:  # за секунду"
1163
   ]
1164
  },
1165
  {
1166
   "cell_type": "code",
1167
   "execution_count": null,
1168
   "metadata": {},
1169
   "outputs": [],
1170
   "source": []
1171
  },
1172
  {
1173
   "cell_type": "code",
1174
   "execution_count": null,
1175
   "metadata": {},
1176
   "outputs": [],
1177
   "source": []
1178
  },
1179
  {
1180
   "cell_type": "code",
1181
   "execution_count": null,
1182
   "metadata": {},
1183
   "outputs": [],
1184
   "source": []
1185
  }
1186
 ],
1187
 "metadata": {
1188
  "kernelspec": {
1189
   "display_name": "Python 3 (ipykernel)",
1190
   "language": "python",
1191
   "name": "python3"
1192
  },
1193
  "language_info": {
1194
   "codemirror_mode": {
1195
    "name": "ipython",
1196
    "version": 3
1197
   },
1198
   "file_extension": ".py",
1199
   "mimetype": "text/x-python",
1200
   "name": "python",
1201
   "nbconvert_exporter": "python",
1202
   "pygments_lexer": "ipython3",
1203
   "version": "3.9.13"
1204
  }
1205
 },
1206
 "nbformat": 4,
1207
 "nbformat_minor": 2
1208
}
1209