test

1
{
2
  "nbformat": 4,
3
  "nbformat_minor": 0,
4
  "metadata": {
5
    "colab": {
6
      "provenance": []
7
    },
8
    "kernelspec": {
9
      "name": "python3",
10
      "display_name": "Python 3"
11
    },
12
    "language_info": {
13
      "name": "python"
14
    }
15
  },
16
  "cells": [
17
    {
18
      "cell_type": "markdown",
19
      "source": [
20
        "# **Pandas** Важные методы форматирования данных"
21
      ],
22
      "metadata": {
23
        "id": "y7i7PVp1ZaAR"
24
      }
25
    },
26
    {
27
      "cell_type": "markdown",
28
      "source": [
29
        "В этом занятии речь пойдет о методах форматирования данных, часто используемых в проектах data science: **merge, sort, reset_index и fillna.** Конечно, есть и другие, поэтому в конце статьи будет шпаргалка с функциями и методами, которые также могут пригодиться."
30
      ],
31
      "metadata": {
32
        "id": "XuDSSRjFZLK1"
33
      }
34
    },
35
    {
36
      "cell_type": "markdown",
37
      "source": [
38
        "## Merge в pandas («объединение» Data Frames)"
39
      ],
40
      "metadata": {
41
        "id": "QWx9qBvVZhSh"
42
      }
43
    },
44
    {
45
      "cell_type": "markdown",
46
      "source": [
47
        "В реальных проектах данные обычно не хранятся в одной таблице. Вместо нее используется много маленьких. И на то есть несколько причин. С помощью нескольких таблиц данными легче управлять, проще избегать «многословия», можно экономить место на диске, а запросы к таблицам обрабатываются быстрее.\n",
48
        "\n",
49
        "Суть в том, что при работе с данными довольно часто придется вытаскивать данные из двух и более разных страниц. Это делается с помощью merge.\n",
50
        "\n",
51
        "Примечание: хотя в pandas это называется merge, метод почти не отличается от JOIN в SQL.\n",
52
        "\n",
53
        "Рассмотрим пример. Для этого можно взять DataFrame zoo, в котором есть разные животные. Но нам понадобится еще один DataFrame — zoo_eats, в котором будет описаны пищевые требования каждого вида."
54
      ],
55
      "metadata": {
56
        "id": "chLIJ-3fbX6d"
57
      }
58
    },
59
    {
60
      "cell_type": "markdown",
61
      "source": [
62
        "/content/merge-v-pandas.png"
63
      ],
64
      "metadata": {
65
        "id": "i-6DLYz9bwp5"
66
      }
67
    },
68
    {
69
      "cell_type": "markdown",
70
      "source": [
71
        "Теперь нужно объединить два эти Data Frames в один. Чтобы получилось нечто подобное:"
72
      ],
73
      "metadata": {
74
        "id": "oAM3OnnmcAjW"
75
      }
76
    },
77
    {
78
      "cell_type": "markdown",
79
      "source": [
80
        "/content/obedinenie-dvuh-data-frames-v-odin.png"
81
      ],
82
      "metadata": {
83
        "id": "WhLVAeNScBQb"
84
      }
85
    },
86
    {
87
      "cell_type": "markdown",
88
      "source": [
89
        "В этой таблице можно проанализировать, например, сколько животных в зоопарке едят мясо или овощи.\n",
90
        "\n"
91
      ],
92
      "metadata": {
93
        "id": "qBvhuthicXuy"
94
      }
95
    },
96
    {
97
      "cell_type": "markdown",
98
      "source": [
99
        "## Как делается merge"
100
      ],
101
      "metadata": {
102
        "id": "vXMXM_7xcdfo"
103
      }
104
    },
105
    {
106
      "cell_type": "markdown",
107
      "source": [
108
        "В первую очередь нужно создать DataFrame *zoo_eats*, потому что zoo уже имеется из прошлых частей. Для упрощения задачи вот исходные данные:"
109
      ],
110
      "metadata": {
111
        "id": "GbCqqbdojE3F"
112
      }
113
    },
114
    {
115
      "cell_type": "code",
116
      "source": [
117
        "animal;food\n",
118
        "elephant;vegetables\n",
119
        "tiger;meat\n",
120
        "kangaroo;vegetables\n",
121
        "zebra;vegetables\n",
122
        "giraffe;vegetables"
123
      ],
124
      "metadata": {
125
        "id": "u1jRK9JCjIyM"
126
      },
127
      "execution_count": null,
128
      "outputs": []
129
    },
130
    {
131
      "cell_type": "markdown",
132
      "source": [
133
        "Импортируем библиотеку Pandas"
134
      ],
135
      "metadata": {
136
        "id": "WKAPB3mF08GZ"
137
      }
138
    },
139
    {
140
      "cell_type": "code",
141
      "source": [
142
        "import pandas as pd"
143
      ],
144
      "metadata": {
145
        "id": "56ExKZnE0ifL"
146
      },
147
      "execution_count": 4,
148
      "outputs": []
149
    },
150
    {
151
      "cell_type": "markdown",
152
      "source": [
153
        "Прочитаем файл zoo.csv"
154
      ],
155
      "metadata": {
156
        "id": "Cv5c09-X0xlE"
157
      }
158
    },
159
    {
160
      "cell_type": "code",
161
      "source": [
162
        "zoo = pd.read_csv('/content/zoo.csv')"
163
      ],
164
      "metadata": {
165
        "id": "w0Ohf5Jp1BrS"
166
      },
167
      "execution_count": 5,
168
      "outputs": []
169
    },
170
    {
171
      "cell_type": "code",
172
      "source": [
173
        "zoo_eats = pd.DataFrame([['elephant','vegetables'], ['tiger','meat'], ['kangaroo','vegetables'], ['zebra','vegetables'], ['giraffe','vegetables']], columns=['animal', 'food'])"
174
      ],
175
      "metadata": {
176
        "id": "nWy1tqOloF-s"
177
      },
178
      "execution_count": 6,
179
      "outputs": []
180
    },
181
    {
182
      "cell_type": "markdown",
183
      "source": [
184
        "И вот готов DataFrame zoo_eats.\n",
185
        "\n"
186
      ],
187
      "metadata": {
188
        "id": "vmvoZNMEoLI-"
189
      }
190
    },
191
    {
192
      "cell_type": "markdown",
193
      "source": [
194
        "Теперь пришло время метода merge:"
195
      ],
196
      "metadata": {
197
        "id": "UFjZA_iBoNdt"
198
      }
199
    },
200
    {
201
      "cell_type": "code",
202
      "source": [
203
        "zoo.merge(zoo_eats)"
204
      ],
205
      "metadata": {
206
        "id": "sn_zFr9moPTt"
207
      },
208
      "execution_count": null,
209
      "outputs": []
210
    },
211
    {
212
      "cell_type": "markdown",
213
      "source": [
214
        "Это было просто, но стоит разобрать, что сейчас произошло:\n",
215
        "\n",
216
        "Сначала был указан первый DataFrame (zoo). Потом к нему применен метод .merge(). В качестве его параметра выступает новый DataFrame (zoo_eats). Можно было сделать и наоборот:"
217
      ],
218
      "metadata": {
219
        "id": "VB87V8qToUNl"
220
      }
221
    },
222
    {
223
      "cell_type": "code",
224
      "source": [
225
        "zoo_eats.merge(zoo)"
226
      ],
227
      "metadata": {
228
        "id": "5Q5Rb-XyoYOs"
229
      },
230
      "execution_count": null,
231
      "outputs": []
232
    },
233
    {
234
      "cell_type": "markdown",
235
      "source": [
236
        "Это то же самое, что и:"
237
      ],
238
      "metadata": {
239
        "id": "fCPVJ069oZtg"
240
      }
241
    },
242
    {
243
      "cell_type": "code",
244
      "source": [
245
        "zoo.merge(zoo_eats)"
246
      ],
247
      "metadata": {
248
        "id": "YcqZ75f3obNm"
249
      },
250
      "execution_count": null,
251
      "outputs": []
252
    },
253
    {
254
      "cell_type": "markdown",
255
      "source": [
256
        "Разница будет лишь в порядке колонок в финальной таблице."
257
      ],
258
      "metadata": {
259
        "id": "ymBnV8uQodV3"
260
      }
261
    },
262
    {
263
      "cell_type": "markdown",
264
      "source": [
265
        "## Способы объединения: inner, outer, left, right"
266
      ],
267
      "metadata": {
268
        "id": "olyOVUZCofdT"
269
      }
270
    },
271
    {
272
      "cell_type": "markdown",
273
      "source": [
274
        "Базовый метод merge довольно прост. Но иногда к нему нужно добавить несколько параметров.\n",
275
        "\n",
276
        "Один из самых важных вопросов — как именно нужно объединять эти таблицы. В SQL есть 4 типа JOIN."
277
      ],
278
      "metadata": {
279
        "id": "qcgj_ZIXojvE"
280
      }
281
    },
282
    {
283
      "cell_type": "markdown",
284
      "source": [
285
        "/content/tipy-sliyaniya-dataframe.png"
286
      ],
287
      "metadata": {
288
        "id": "vhnC2VphorI4"
289
      }
290
    },
291
    {
292
      "cell_type": "markdown",
293
      "source": [
294
        "В случае с merge в pandas в теории это работает аналогичным образом.\n",
295
        "\n",
296
        "При выборе INNER JOIN (вид по умолчанию в SQL и pandas) объединяются только те значения, которые можно найти в обеих таблицах. В случае же с OUTER JOIN объединяются все значения, даже если некоторые из них есть только в одной таблице.\n",
297
        "\n",
298
        "Конкретный пример: в zoo_eats нет значения lion. А в zoo нет значения giraffe. По умолчанию использовался метод INNER, поэтому и львы, и жирафы пропали из таблицы. Но бывают случаи, когда нужно, чтобы все значения оставались в объединенном DataFrame. Этого можно добиться следующим образом:\n",
299
        "\n"
300
      ],
301
      "metadata": {
302
        "id": "aZxxfXtSotRX"
303
      }
304
    },
305
    {
306
      "cell_type": "code",
307
      "source": [
308
        "zoo.merge(zoo_eats, how='outer')"
309
      ],
310
      "metadata": {
311
        "id": "TjUCx6kLovT4"
312
      },
313
      "execution_count": null,
314
      "outputs": []
315
    },
316
    {
317
      "cell_type": "markdown",
318
      "source": [
319
        "/content/obedinenie-dvuh-dataframes-metod-outer.png"
320
      ],
321
      "metadata": {
322
        "id": "njxcI96aoys3"
323
      }
324
    },
325
    {
326
      "cell_type": "markdown",
327
      "source": [
328
        "В этот раз львы и жирафы вернулись. Но поскольку вторая таблица не предоставила конкретных данных, то вместо значения ставится пропуск (NaN).\n",
329
        "\n",
330
        "Логичнее всего было бы оставить в таблице львов, но не жирафов. В таком случае будет три типа еды: vegetables, meat и NaN (что, фактически, значит, «информации нет»). Если же в таблице останутся жирафы, это может запутать, потому что в зоопарке-то этого вида животных все равно нет. Поэтому следует воспользоваться параметром how='left' при объединении.\n",
331
        "\n",
332
        "\n",
333
        "Вот так:"
334
      ],
335
      "metadata": {
336
        "id": "1iSMdYVho7IV"
337
      }
338
    },
339
    {
340
      "cell_type": "code",
341
      "source": [
342
        "zoo.merge(zoo_eats, how='left')"
343
      ],
344
      "metadata": {
345
        "id": "fn7Uzagao9XE"
346
      },
347
      "execution_count": null,
348
      "outputs": []
349
    },
350
    {
351
      "cell_type": "markdown",
352
      "source": [
353
        "Теперь в таблице есть вся необходимая информация, и ничего лишнего. how = 'left' заберет все значения из левой таблицы (zoo), но из правой (zoo_eats) использует только те значения, которые есть в левой.\n",
354
        "\n",
355
        "Еще раз взглянем на типы объединения:"
356
      ],
357
      "metadata": {
358
        "id": "NstpPy3do_Cp"
359
      }
360
    },
361
    {
362
      "cell_type": "markdown",
363
      "source": [
364
        "/content/tipy-sliyaniya-dataframe_2.png"
365
      ],
366
      "metadata": {
367
        "id": "T93KaIHLo_fj"
368
      }
369
    },
370
    {
371
      "cell_type": "markdown",
372
      "source": [
373
        "## Merge в pandas. По какой колонке"
374
      ],
375
      "metadata": {
376
        "id": "k9RoSjwtpJU4"
377
      }
378
    },
379
    {
380
      "cell_type": "markdown",
381
      "source": [
382
        "Для использования merge библиотеке pandas нужны ключевые колонки, на основе которых будет проходить объединение (в случае с примером это колонка animal). Иногда pandas не сможет распознать их автоматически, и тогда нужно указать названия колонок. Для этого нужны параметры left_on и right_on.\n",
383
        "\n",
384
        "Например, последний merge мог бы выглядеть следующим образом:"
385
      ],
386
      "metadata": {
387
        "id": "SDiFUYqhpNV-"
388
      }
389
    },
390
    {
391
      "cell_type": "code",
392
      "source": [
393
        "zoo.merge(zoo_eats, how = 'left', left_on='animal', right_on='animal')"
394
      ],
395
      "metadata": {
396
        "id": "LVdeLCTapQ4W"
397
      },
398
      "execution_count": null,
399
      "outputs": []
400
    },
401
    {
402
      "cell_type": "markdown",
403
      "source": [
404
        "Merge в pandas — довольно сложный метод, но остальные будут намного проще."
405
      ],
406
      "metadata": {
407
        "id": "UHPKdQv_pSxe"
408
      }
409
    },
410
    {
411
      "cell_type": "markdown",
412
      "source": [
413
        "## Сортировка в pandas"
414
      ],
415
      "metadata": {
416
        "id": "mJs26FaVpVnS"
417
      }
418
    },
419
    {
420
      "cell_type": "markdown",
421
      "source": [
422
        "Сортировка необходима. Базовый метод сортировки в pandas совсем не сложный. Функция называется sort_values() и работает она следующим образом:\n",
423
        "\n"
424
      ],
425
      "metadata": {
426
        "id": "wTiVrSzopcbV"
427
      }
428
    },
429
    {
430
      "cell_type": "code",
431
      "source": [
432
        "zoo.sort_values('water_need')"
433
      ],
434
      "metadata": {
435
        "id": "Wa22DKftzTh0"
436
      },
437
      "execution_count": null,
438
      "outputs": []
439
    },
440
    {
441
      "cell_type": "markdown",
442
      "source": [
443
        "Единственный используемый параметр — название колонки, water_need в этом случае. Довольно часто приходится сортировать на основе нескольких колонок. В таком случае для них нужно использовать ключевое слово **by:**"
444
      ],
445
      "metadata": {
446
        "id": "_P-xoHLAzWrb"
447
      }
448
    },
449
    {
450
      "cell_type": "code",
451
      "source": [
452
        "zoo.sort_values(by=['animal', 'water_need'])"
453
      ],
454
      "metadata": {
455
        "id": "kLPt8UzJzZ-r"
456
      },
457
      "execution_count": null,
458
      "outputs": []
459
    },
460
    {
461
      "cell_type": "markdown",
462
      "source": [
463
        "**sort_values** сортирует в порядке возрастания, но это можно поменять на убывание:"
464
      ],
465
      "metadata": {
466
        "id": "IC58vt2IziZY"
467
      }
468
    },
469
    {
470
      "cell_type": "code",
471
      "source": [
472
        "zoo.sort_values(by=['water_need'], ascending=False)"
473
      ],
474
      "metadata": {
475
        "id": "D4X67YmqzoZU"
476
      },
477
      "execution_count": null,
478
      "outputs": []
479
    },
480
    {
481
      "cell_type": "markdown",
482
      "source": [
483
        "### reset_index()"
484
      ],
485
      "metadata": {
486
        "id": "LUT2JOO0zqyv"
487
      }
488
    },
489
    {
490
      "cell_type": "markdown",
491
      "source": [
492
        "Обратите внимание на беспорядок в нумерации после последней сортировки"
493
      ],
494
      "metadata": {
495
        "id": "F8fJ5ax7zubn"
496
      }
497
    },
498
    {
499
      "cell_type": "markdown",
500
      "source": [
501
        "Это не просто выглядит некрасиво… неправильная индексация может испортить визуализации или повлиять на то, как работают модели машинного обучения.\n",
502
        "\n",
503
        "В случае изменения DataFrame нужно переиндексировать строки. Для этого можно использовать метод **reset_index()**. Например:"
504
      ],
505
      "metadata": {
506
        "id": "QvLHta3-z1NU"
507
      }
508
    },
509
    {
510
      "cell_type": "code",
511
      "source": [
512
        "zoo.sort_values(by=['water_need'], ascending=False).reset_index()"
513
      ],
514
      "metadata": {
515
        "id": "cGWGS3eaz4pL"
516
      },
517
      "execution_count": null,
518
      "outputs": []
519
    },
520
    {
521
      "cell_type": "markdown",
522
      "source": [
523
        "Можно заметить, что новый DataFrame также хранит старые индексы. Если они не нужны, их можно удалить с помощью параметра **drop=True** в функции:"
524
      ],
525
      "metadata": {
526
        "id": "1f9KRFrE0CFO"
527
      }
528
    },
529
    {
530
      "cell_type": "code",
531
      "source": [
532
        "zoo.sort_values(by = ['water_need'], ascending = False).reset_index(drop = True)"
533
      ],
534
      "metadata": {
535
        "id": "1V_0FSNk0FtD"
536
      },
537
      "execution_count": null,
538
      "outputs": []
539
    },
540
    {
541
      "cell_type": "markdown",
542
      "source": [
543
        "### Fillna"
544
      ],
545
      "metadata": {
546
        "id": "6QHL2BPE0Hxo"
547
      }
548
    },
549
    {
550
      "cell_type": "markdown",
551
      "source": [
552
        "*fillna — это слова fill( заполнить) и na(не доступно).*"
553
      ],
554
      "metadata": {
555
        "id": "7ZiM5GKN0MRe"
556
      }
557
    },
558
    {
559
      "cell_type": "markdown",
560
      "source": [
561
        "Запустим еще раз метод left-merge:"
562
      ],
563
      "metadata": {
564
        "id": "qr5ti9Kr0PD6"
565
      }
566
    },
567
    {
568
      "cell_type": "code",
569
      "source": [
570
        "zoo.merge(zoo_eats, how='left')"
571
      ],
572
      "metadata": {
573
        "id": "S3GAapE50Q_p"
574
      },
575
      "execution_count": null,
576
      "outputs": []
577
    },
578
    {
579
      "cell_type": "markdown",
580
      "source": [
581
        "Это все животные. Проблема только в том, что для львов есть значение NaN. Само по себе это значение может отвлекать, поэтому лучше заменять его на что-то более осмысленное. Иногда это может быть 0, в других случаях — строка. Но в этот раз обойдемся unknown. Функция **fillna()** автоматически найдет и заменит все значения **NaN** в DataFrame:"
582
      ],
583
      "metadata": {
584
        "id": "-aGVuus10SxN"
585
      }
586
    },
587
    {
588
      "cell_type": "code",
589
      "source": [
590
        "zoo.merge(zoo_eats, how='left').fillna('unknown')"
591
      ],
592
      "metadata": {
593
        "id": "cJhd2FJ00Y-c"
594
      },
595
      "execution_count": null,
596
      "outputs": []
597
    }
598
  ]
599
}