![](\"https://hackernoon.com/hn-images/1*ZUSN2Xhq7MsEMjCvNOy-Zw.jpeg\")
\n"
16 | ]
17 | },
18 | {
19 | "cell_type": "markdown",
20 | "metadata": {
21 | "colab_type": "text",
22 | "id": "6kMhXS8lKSam"
23 | },
24 | "source": [
25 | "нас спасут функции! \n",
26 | "\n",
27 | "Функция в python - это такой объект, который выполняет какое-то действие c данными, которые она принимает на вход.\n",
28 | "\n",
29 | "- То, что функция принимает, называется *аргументом* и записывается в скобках. У функции может быть как один, ноль или несколько аргументов.\n",
30 | "\n",
31 | "- То, что функция возвращает, называется *значением*.\n",
32 | "\n",
33 | "\n",
34 | "Обычно функция определяется с помощью инструкции ```def```, за которым следует название функции со скобками и двоеточием. \n",
35 | "\n",
36 | "Давайте создадим самую простую функцию:"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": 3,
42 | "metadata": {
43 | "colab": {},
44 | "colab_type": "code",
45 | "id": "L2cPPSNm8xaw"
46 | },
47 | "outputs": [],
48 | "source": [
49 | "def hello():\n",
50 | "\n",
51 | " print (\"hello =^_^=\")"
52 | ]
53 | },
54 | {
55 | "cell_type": "code",
56 | "execution_count": 4,
57 | "metadata": {
58 | "colab": {
59 | "base_uri": "https://localhost:8080/",
60 | "height": 34
61 | },
62 | "colab_type": "code",
63 | "id": "nOu2GAWXN9b1",
64 | "outputId": "9982f7b3-141d-47c7-93c2-c3b0c6e79e93"
65 | },
66 | "outputs": [
67 | {
68 | "name": "stdout",
69 | "output_type": "stream",
70 | "text": [
71 | "hello =^_^=\n"
72 | ]
73 | }
74 | ],
75 | "source": [
76 | "hello() # чтобы функция cработала, ее надо вызвать"
77 | ]
78 | },
79 | {
80 | "cell_type": "code",
81 | "execution_count": 5,
82 | "metadata": {
83 | "colab": {},
84 | "colab_type": "code",
85 | "id": "4bNVEzUnOFPZ"
86 | },
87 | "outputs": [],
88 | "source": [
89 | "# усложним функцию\n",
90 | "\n",
91 | "def personal_hello():\n",
92 | " name = input(\"Как Вас зовут?\")\n",
93 | " print (\"Добрый день,\", name)\n"
94 | ]
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": 6,
99 | "metadata": {
100 | "colab": {
101 | "base_uri": "https://localhost:8080/",
102 | "height": 51
103 | },
104 | "colab_type": "code",
105 | "id": "hrzq20zGOxX9",
106 | "outputId": "e63cdbd7-ef8d-4f46-985e-4da9cdf06550"
107 | },
108 | "outputs": [
109 | {
110 | "name": "stdin",
111 | "output_type": "stream",
112 | "text": [
113 | "Как Вас зовут? N\n"
114 | ]
115 | },
116 | {
117 | "name": "stdout",
118 | "output_type": "stream",
119 | "text": [
120 | "Добрый день, N\n"
121 | ]
122 | }
123 | ],
124 | "source": [
125 | "personal_hello()"
126 | ]
127 | },
128 | {
129 | "cell_type": "markdown",
130 | "metadata": {},
131 | "source": [
132 | "Можно написать функцию так, чтобы она не только совершала действие, но и возвращала некоторый результат. Понадобится ключевое слово ```return```"
133 | ]
134 | },
135 | {
136 | "cell_type": "code",
137 | "execution_count": 7,
138 | "metadata": {
139 | "colab": {},
140 | "colab_type": "code",
141 | "id": "3nt1yPVfOz6E"
142 | },
143 | "outputs": [],
144 | "source": [
145 | "# функция с возвратом значения\n",
146 | "\n",
147 | "def add(x,y):\n",
148 | " res = x+y\n",
149 | " return res"
150 | ]
151 | },
152 | {
153 | "cell_type": "code",
154 | "execution_count": 16,
155 | "metadata": {
156 | "colab": {
157 | "base_uri": "https://localhost:8080/",
158 | "height": 34
159 | },
160 | "colab_type": "code",
161 | "id": "Mi1_v9yKPNHu",
162 | "outputId": "8c4be812-afc5-47a5-8e16-da580cde1ae8"
163 | },
164 | "outputs": [
165 | {
166 | "data": {
167 | "text/plain": [
168 | "'hi'"
169 | ]
170 | },
171 | "execution_count": 16,
172 | "metadata": {},
173 | "output_type": "execute_result"
174 | }
175 | ],
176 | "source": [
177 | "add(\"h\",\"i\") # так мы вызвали функцию и передали аргументы в скобках"
178 | ]
179 | },
180 | {
181 | "cell_type": "code",
182 | "execution_count": 17,
183 | "metadata": {},
184 | "outputs": [
185 | {
186 | "data": {
187 | "text/plain": [
188 | "8.6"
189 | ]
190 | },
191 | "execution_count": 17,
192 | "metadata": {},
193 | "output_type": "execute_result"
194 | }
195 | ],
196 | "source": [
197 | "add(0.6,8) "
198 | ]
199 | },
200 | {
201 | "cell_type": "markdown",
202 | "metadata": {},
203 | "source": [
204 | "а вот пример работы с текстом"
205 | ]
206 | },
207 | {
208 | "cell_type": "code",
209 | "execution_count": 18,
210 | "metadata": {
211 | "colab": {},
212 | "colab_type": "code",
213 | "id": "HbIrUegGQj5M"
214 | },
215 | "outputs": [],
216 | "source": [
217 | "def unique(x): # простая функция, выдающая уникальный набор элементов в объекте\n",
218 | " x = set(x)\n",
219 | " return x"
220 | ]
221 | },
222 | {
223 | "cell_type": "code",
224 | "execution_count": 20,
225 | "metadata": {},
226 | "outputs": [
227 | {
228 | "data": {
229 | "text/plain": [
230 | "{'e', 'h', 'l', 'o'}"
231 | ]
232 | },
233 | "execution_count": 20,
234 | "metadata": {},
235 | "output_type": "execute_result"
236 | }
237 | ],
238 | "source": [
239 | "unique(\"hello\")"
240 | ]
241 | },
242 | {
243 | "cell_type": "code",
244 | "execution_count": 24,
245 | "metadata": {
246 | "colab": {
247 | "base_uri": "https://localhost:8080/",
248 | "height": 34
249 | },
250 | "colab_type": "code",
251 | "id": "RO-7hY7dRlF3",
252 | "outputId": "f0cfd290-d844-489a-f8e1-2a3c536e6f27"
253 | },
254 | "outputs": [
255 | {
256 | "name": "stdout",
257 | "output_type": "stream",
258 | "text": [
259 | "{'n', '.', 'w', 's', 'o', 'a', 'T', ' ', 'h', 'R', 'd', 'l', 'i', 'y', 'e', 'r'}\n"
260 | ]
261 | },
262 | {
263 | "data": {
264 | "text/plain": [
265 | "{'a', 'always', 'and', 'is', 'rose', 'the', 'was'}"
266 | ]
267 | },
268 | "execution_count": 24,
269 | "metadata": {},
270 | "output_type": "execute_result"
271 | }
272 | ],
273 | "source": [
274 | "poem = \"The Rose is a rose and was always a rose.\"\n",
275 | "\n",
276 | "print(unique(poem))\n",
277 | "\n",
278 | "poem = poem.strip(\".-:!?–,\").lower().split() #предобратобка\n",
279 | "\n",
280 | "unique(poem) # множество уникальных токенов "
281 | ]
282 | },
283 | {
284 | "cell_type": "code",
285 | "execution_count": 37,
286 | "metadata": {
287 | "colab": {},
288 | "colab_type": "code",
289 | "id": "FUN_ywNqU-Cl"
290 | },
291 | "outputs": [],
292 | "source": [
293 | "# функция, убирающая пунктуацию\n",
294 | "\n",
295 | "import string\n",
296 | "\n",
297 | "def normalize(text):\n",
298 | " normalized = text.lower().translate(str.maketrans('','',string.punctuation)).split()\n",
299 | " return normalized"
300 | ]
301 | },
302 | {
303 | "cell_type": "code",
304 | "execution_count": 39,
305 | "metadata": {
306 | "colab": {
307 | "base_uri": "https://localhost:8080/",
308 | "height": 697
309 | },
310 | "colab_type": "code",
311 | "id": "TZ5Zkha9c0uk",
312 | "outputId": "db5692da-7a61-4048-cd0c-d274ee07e7c0"
313 | },
314 | "outputs": [
315 | {
316 | "name": "stdout",
317 | "output_type": "stream",
318 | "text": [
319 | "['i', 'had', 'heard', 'that', 'mcdonalds', 'never', 'decompose', 'so', 'i', 'just', 'wanted', 'to', 'see', 'if', 'it', 'was', 'true', 'or', 'not', 'hjortur', 'smarason', 'told', 'afp', 'this', 'week', 'its', '10', 'years', 'since', 'the', 'seemingly', 'indestructible', 'meal', 'was', 'purchased', 'and', 'it', 'barely', 'looks', 'a', 'day', 'older']\n"
320 | ]
321 | }
322 | ],
323 | "source": [
324 | "# попробуем на тексте: \n",
325 | "\n",
326 | "news = \"\"\" \"\\I had heard that McDonald\\'s never decompose so I just wanted to see if it was true or not,\\\" Hjortur Smarason told AFP. This week, it's 10 years since the seemingly indestructible meal was purchased, and it barely looks a day older.\"\"\"\n",
327 | "\n",
328 | "print(normalize(news))"
329 | ]
330 | },
331 | {
332 | "cell_type": "markdown",
333 | "metadata": {
334 | "colab_type": "text",
335 | "id": "kt9JszRTgh4-"
336 | },
337 | "source": [
338 | "### Аргументы функции\n",
339 | "Функция может принимать произвольное количество аргументов (или не принимать вообще). \n",
340 | "\n",
341 | "Существуют функции с произвольным числом аргументов, функции с позиционными и именованными аргументами, обязательными и необязательными.\n",
342 | "\n",
343 | "давайте разбираться\n",
344 | "\n",
345 | "1. позиционные и именованные аргументы"
346 | ]
347 | },
348 | {
349 | "cell_type": "code",
350 | "execution_count": 40,
351 | "metadata": {
352 | "colab": {},
353 | "colab_type": "code",
354 | "id": "dVnd5e7Ge_M4"
355 | },
356 | "outputs": [],
357 | "source": [
358 | "def birthday1(name, age):\n",
359 | " print( \"С днем рождения , \", name , \"!\", \" Вам сегодня исполняется\", age)"
360 | ]
361 | },
362 | {
363 | "cell_type": "markdown",
364 | "metadata": {
365 | "colab_type": "text",
366 | "id": "X9CQVWnpoGzF"
367 | },
368 | "source": [
369 | "**позиционные аргументы**\n",
370 | "\n",
371 | "важен порядок ввода"
372 | ]
373 | },
374 | {
375 | "cell_type": "code",
376 | "execution_count": 41,
377 | "metadata": {
378 | "colab": {
379 | "base_uri": "https://localhost:8080/",
380 | "height": 34
381 | },
382 | "colab_type": "code",
383 | "id": "kdwjGqLQmduF",
384 | "outputId": "c9abcb8e-afa2-4319-af28-b54f0609ef74"
385 | },
386 | "outputs": [
387 | {
388 | "name": "stdout",
389 | "output_type": "stream",
390 | "text": [
391 | "С днем рождения , дорогой друг ! Вам сегодня исполняется 1\n"
392 | ]
393 | }
394 | ],
395 | "source": [
396 | "birthday1(\"дорогой друг\" , 1)"
397 | ]
398 | },
399 | {
400 | "cell_type": "code",
401 | "execution_count": 42,
402 | "metadata": {
403 | "colab": {
404 | "base_uri": "https://localhost:8080/",
405 | "height": 34
406 | },
407 | "colab_type": "code",
408 | "id": "igl8L9MvnmLk",
409 | "outputId": "0b4c9313-9be7-43a7-bd9f-3e0816fb51d9"
410 | },
411 | "outputs": [
412 | {
413 | "name": "stdout",
414 | "output_type": "stream",
415 | "text": [
416 | "С днем рождения , 1 ! Вам сегодня исполняется дорогой друг\n"
417 | ]
418 | }
419 | ],
420 | "source": [
421 | "# Проблема позиционных аргументов\n",
422 | "\n",
423 | "birthday1(1, \"дорогой друг\")"
424 | ]
425 | },
426 | {
427 | "cell_type": "markdown",
428 | "metadata": {
429 | "colab_type": "text",
430 | "id": "o-xxHvGSn3a4"
431 | },
432 | "source": [
433 | "**именные аргументы**\n",
434 | "\n",
435 | "Вне зависимости от порядка, все хорошо."
436 | ]
437 | },
438 | {
439 | "cell_type": "code",
440 | "execution_count": 43,
441 | "metadata": {
442 | "colab": {
443 | "base_uri": "https://localhost:8080/",
444 | "height": 34
445 | },
446 | "colab_type": "code",
447 | "id": "atGOHsObmoGy",
448 | "outputId": "dee6d4c3-cd25-4d78-a352-c23811cc568c"
449 | },
450 | "outputs": [
451 | {
452 | "name": "stdout",
453 | "output_type": "stream",
454 | "text": [
455 | "С днем рождения , дорогой друг ! Вам сегодня исполняется 1\n"
456 | ]
457 | }
458 | ],
459 | "source": [
460 | "birthday1(name = \"дорогой друг\", age = 1) "
461 | ]
462 | },
463 | {
464 | "cell_type": "code",
465 | "execution_count": 46,
466 | "metadata": {
467 | "colab": {
468 | "base_uri": "https://localhost:8080/",
469 | "height": 34
470 | },
471 | "colab_type": "code",
472 | "id": "oHbEHLVKmxnw",
473 | "outputId": "a7642b6d-14ef-4920-c914-ae0e1720047d"
474 | },
475 | "outputs": [
476 | {
477 | "name": "stdout",
478 | "output_type": "stream",
479 | "text": [
480 | "С днем рождения , Настя ! Вам сегодня исполняется 270\n"
481 | ]
482 | }
483 | ],
484 | "source": [
485 | "birthday1(age = 270, name = \"Настя\")"
486 | ]
487 | },
488 | {
489 | "cell_type": "markdown",
490 | "metadata": {
491 | "colab_type": "text",
492 | "id": "Kjx2bycnsi9p"
493 | },
494 | "source": [
495 | "### бонус: lambda func"
496 | ]
497 | },
498 | {
499 | "cell_type": "markdown",
500 | "metadata": {
501 | "colab_type": "text",
502 | "id": "-AjT1BdWsvvx"
503 | },
504 | "source": [
505 | "Анонимные функции:\n",
506 | "* могут содержать лишь одно действие\n",
507 | "* выполняются быстрее\n",
508 | "* не обязательно присваивать переменной (не нужен def)\n",
509 | "* не требуется return\n",
510 | "\n",
511 | "\n",
512 | "обычно используются для одноразовых функций \n",
513 | "\n",
514 | "создаются с помощью ключевого слова ```lambda```"
515 | ]
516 | },
517 | {
518 | "cell_type": "code",
519 | "execution_count": 47,
520 | "metadata": {
521 | "colab": {},
522 | "colab_type": "code",
523 | "id": "tQoxZXdPsWFc"
524 | },
525 | "outputs": [],
526 | "source": [
527 | "lambda x, y: x + y # задали (до двоеточия аргументы, после - действие с ними)"
528 | ]
529 | },
530 | {
531 | "cell_type": "code",
532 | "execution_count": null,
533 | "metadata": {},
534 | "outputs": [],
535 | "source": [
536 | "func = lambda x, y: x + y #так можно сохранить в переменную"
537 | ]
538 | },
539 | {
540 | "cell_type": "code",
541 | "execution_count": 50,
542 | "metadata": {
543 | "colab": {
544 | "base_uri": "https://localhost:8080/",
545 | "height": 34
546 | },
547 | "colab_type": "code",
548 | "id": "XKyQxTNVtTML",
549 | "outputId": "7796ece3-5ad5-48c3-cc34-bad7991aea0f"
550 | },
551 | "outputs": [
552 | {
553 | "data": {
554 | "text/plain": [
555 | "11"
556 | ]
557 | },
558 | "execution_count": 50,
559 | "metadata": {},
560 | "output_type": "execute_result"
561 | }
562 | ],
563 | "source": [
564 | "func(4, 7) # вызываем, подав аргументы"
565 | ]
566 | },
567 | {
568 | "cell_type": "code",
569 | "execution_count": 51,
570 | "metadata": {
571 | "colab": {
572 | "base_uri": "https://localhost:8080/",
573 | "height": 34
574 | },
575 | "colab_type": "code",
576 | "id": "vOoz51D-tgTP",
577 | "outputId": "e1c067e5-90ea-4143-c293-9a58046ed895"
578 | },
579 | "outputs": [
580 | {
581 | "data": {
582 | "text/plain": [
583 | "'i write code in Python'"
584 | ]
585 | },
586 | "execution_count": 51,
587 | "metadata": {},
588 | "output_type": "execute_result"
589 | }
590 | ],
591 | "source": [
592 | "func(\"i write\",\" code in Python\") # подаем строки как аргументы, их тоже можно конкатенировать"
593 | ]
594 | },
595 | {
596 | "cell_type": "code",
597 | "execution_count": null,
598 | "metadata": {},
599 | "outputs": [],
600 | "source": []
601 | }
602 | ],
603 | "metadata": {
604 | "colab": {
605 | "collapsed_sections": [],
606 | "include_colab_link": true,
607 | "name": "Sat_02Nov_19.ipynb",
608 | "provenance": []
609 | },
610 | "kernelspec": {
611 | "display_name": "Python 3",
612 | "language": "python",
613 | "name": "python3"
614 | },
615 | "language_info": {
616 | "codemirror_mode": {
617 | "name": "ipython",
618 | "version": 3
619 | },
620 | "file_extension": ".py",
621 | "mimetype": "text/x-python",
622 | "name": "python",
623 | "nbconvert_exporter": "python",
624 | "pygments_lexer": "ipython3",
625 | "version": "3.8.2"
626 | }
627 | },
628 | "nbformat": 4,
629 | "nbformat_minor": 4
630 | }
631 |
--------------------------------------------------------------------------------
/notebooks/classes.py:
--------------------------------------------------------------------------------
1 | def test_func():
2 | print("successfully imported")
3 |
4 | class NLP(object):
5 | def __init__(self,text):
6 | self.text = text
7 |
8 | def preprocess(self):
9 | return self.text.lower().strip().split()
--------------------------------------------------------------------------------
/notebooks/files_OS.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "colab_type": "text",
7 | "id": "kIZidEDRSGBg"
8 | },
9 | "source": [
10 | "Часто, чтобы поработать над какой-то задачей, нам нужно работать с файлами, в которых хранятся данные, перемещаться среди папок и тд. Для решениях этих задач, в питоне существует [модуль os](https://pythonworld.ru/moduli/modul-os.html)."
11 | ]
12 | },
13 | {
14 | "cell_type": "code",
15 | "execution_count": null,
16 | "metadata": {
17 | "colab": {},
18 | "colab_type": "code",
19 | "id": "0321FMiWSGBp"
20 | },
21 | "outputs": [],
22 | "source": [
23 | "import os"
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {},
29 | "source": [
30 | "### Рассмотрим основные методы"
31 | ]
32 | },
33 | {
34 | "cell_type": "code",
35 | "execution_count": null,
36 | "metadata": {
37 | "colab": {},
38 | "colab_type": "code",
39 | "id": "Dt59vqBHSGB6"
40 | },
41 | "outputs": [],
42 | "source": [
43 | "# текущая рабочая директория (cwd = current working directory)\n",
44 | "\n",
45 | "x = os.getcwd() "
46 | ]
47 | },
48 | {
49 | "cell_type": "markdown",
50 | "metadata": {},
51 | "source": [
52 | "Для следующих методов в скобках нужно указывать желаемый путь"
53 | ]
54 | },
55 | {
56 | "cell_type": "code",
57 | "execution_count": null,
58 | "metadata": {
59 | "tags": []
60 | },
61 | "outputs": [],
62 | "source": [
63 | "list(os.walk(x)) # перечисляет все папки от топа вниз, в виде кортежа"
64 | ]
65 | },
66 | {
67 | "cell_type": "code",
68 | "execution_count": null,
69 | "metadata": {
70 | "colab": {
71 | "base_uri": "https://localhost:8080/",
72 | "height": 34
73 | },
74 | "colab_type": "code",
75 | "id": "-6u6RCLESGCA",
76 | "outputId": "c1a73ca5-c105-45d8-fafb-288a9a852c17",
77 | "tags": []
78 | },
79 | "outputs": [],
80 | "source": [
81 | "os.listdir(x) # список файлов и директорий в папке"
82 | ]
83 | },
84 | {
85 | "cell_type": "code",
86 | "execution_count": null,
87 | "metadata": {
88 | "colab": {},
89 | "colab_type": "code",
90 | "id": "o192KEJHSGCE"
91 | },
92 | "outputs": [],
93 | "source": [
94 | "os.mkdir(\"new\") # создаёт новую директорию"
95 | ]
96 | },
97 | {
98 | "cell_type": "code",
99 | "execution_count": null,
100 | "metadata": {
101 | "colab": {},
102 | "colab_type": "code",
103 | "id": "pj9svtYtSGB9"
104 | },
105 | "outputs": [],
106 | "source": [
107 | "os.chdir(\"new\") # сменяет текущую рабочую директорию"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": null,
113 | "metadata": {
114 | "colab": {
115 | "base_uri": "https://localhost:8080/",
116 | "height": 34
117 | },
118 | "colab_type": "code",
119 | "id": "L0VYBoD6TF64",
120 | "outputId": "ae26aab1-aaad-4d13-d287-25e58a04a182"
121 | },
122 | "outputs": [],
123 | "source": [
124 | "os.getcwd() # проверим текущую директорию"
125 | ]
126 | },
127 | {
128 | "cell_type": "code",
129 | "execution_count": null,
130 | "metadata": {
131 | "colab": {
132 | "base_uri": "https://localhost:8080/",
133 | "height": 34
134 | },
135 | "colab_type": "code",
136 | "id": "L8WzXb7USGCL",
137 | "outputId": "bc9ea53f-c98b-4569-eb2e-f4535b38bf55"
138 | },
139 | "outputs": [],
140 | "source": [
141 | "os.listdir(\"/content/new\") # посмотрим, что в новой директории"
142 | ]
143 | },
144 | {
145 | "cell_type": "code",
146 | "execution_count": null,
147 | "metadata": {
148 | "colab": {
149 | "base_uri": "https://localhost:8080/",
150 | "height": 34
151 | },
152 | "colab_type": "code",
153 | "id": "MwRp_Bt6SGCa",
154 | "outputId": "17ce6ead-4734-49ee-b93f-084e9b2d8821"
155 | },
156 | "outputs": [],
157 | "source": [
158 | "#os.chdir(\"/content\")\n",
159 | "os.rmdir('/content/new') # удаляет пустую директорию. Чтобы удалить, из нее сначала надо выйти \n",
160 | "# (например, на шаг назад, это делает предыдущая строка)\n",
161 | "os.listdir() # посмотрим на список файлов снова, new уже нет"
162 | ]
163 | },
164 | {
165 | "cell_type": "code",
166 | "execution_count": null,
167 | "metadata": {
168 | "colab": {},
169 | "colab_type": "code",
170 | "id": "CihvMLrkSGCV"
171 | },
172 | "outputs": [],
173 | "source": [
174 | "os.remove('new') # удаляет путь к файлу."
175 | ]
176 | },
177 | {
178 | "cell_type": "code",
179 | "execution_count": null,
180 | "metadata": {
181 | "colab": {},
182 | "colab_type": "code",
183 | "id": "ppZeXif6SGCd",
184 | "outputId": "e21ef6ae-242e-4072-a65d-dfd2c5bed512"
185 | },
186 | "outputs": [],
187 | "source": [
188 | "os.listdir(x) # посмотрим на список еще раз, исчез ли new2"
189 | ]
190 | },
191 | {
192 | "cell_type": "markdown",
193 | "metadata": {
194 | "colab_type": "text",
195 | "id": "EKBeg_6NSGCn"
196 | },
197 | "source": [
198 | "### в модуле os есть свой под-модуль: os.path ( реализует некоторые полезные функции для работы с путями)"
199 | ]
200 | },
201 | {
202 | "cell_type": "code",
203 | "execution_count": null,
204 | "metadata": {
205 | "colab": {},
206 | "colab_type": "code",
207 | "id": "LQ_mGKAj5gzo"
208 | },
209 | "outputs": [],
210 | "source": [
211 | "import os.path # импортим модуль"
212 | ]
213 | },
214 | {
215 | "cell_type": "code",
216 | "execution_count": null,
217 | "metadata": {
218 | "colab": {
219 | "base_uri": "https://localhost:8080/",
220 | "height": 34
221 | },
222 | "colab_type": "code",
223 | "id": "CWEZNUXoSGCo",
224 | "outputId": "8f7fd8a2-7898-4bdd-da91-e5b6f4fab965"
225 | },
226 | "outputs": [],
227 | "source": [
228 | "os.path.abspath(\"new\") # возвращает нормализованный абсолютный путь"
229 | ]
230 | },
231 | {
232 | "cell_type": "code",
233 | "execution_count": null,
234 | "metadata": {
235 | "colab": {
236 | "base_uri": "https://localhost:8080/",
237 | "height": 34
238 | },
239 | "colab_type": "code",
240 | "id": "YBcWrovC6yRj",
241 | "outputId": "16aca1a5-08cb-4a1a-e2b1-d08f2eb26f36"
242 | },
243 | "outputs": [],
244 | "source": [
245 | "os.path.isabs(\"new\") # является ли путь абсолютным"
246 | ]
247 | },
248 | {
249 | "cell_type": "code",
250 | "execution_count": null,
251 | "metadata": {
252 | "colab": {
253 | "base_uri": "https://localhost:8080/",
254 | "height": 34
255 | },
256 | "colab_type": "code",
257 | "id": "olWeC3bf6yHg",
258 | "outputId": "2d0bc56d-68dd-4c0c-ddc6-368197e0aced"
259 | },
260 | "outputs": [],
261 | "source": [
262 | "os.path.isfile(\"new\") # является ли путь файлом"
263 | ]
264 | },
265 | {
266 | "cell_type": "code",
267 | "execution_count": null,
268 | "metadata": {
269 | "colab": {
270 | "base_uri": "https://localhost:8080/",
271 | "height": 34
272 | },
273 | "colab_type": "code",
274 | "id": "-FdpVPhx6x-G",
275 | "outputId": "65477a3c-86a6-44c0-c8fb-d2fb1c648c17"
276 | },
277 | "outputs": [],
278 | "source": [
279 | "os.path.isdir(\"new\") # является ли путь директорией(папкой)"
280 | ]
281 | },
282 | {
283 | "cell_type": "code",
284 | "execution_count": null,
285 | "metadata": {
286 | "colab": {
287 | "base_uri": "https://localhost:8080/",
288 | "height": 34
289 | },
290 | "colab_type": "code",
291 | "id": "0qKfXUzASGCw",
292 | "outputId": "c6b4a06b-6ba0-402c-f5c3-9cd4eaae2535"
293 | },
294 | "outputs": [],
295 | "source": [
296 | "os.path.split(\"/content/new\") #разбивает путь на кортеж (голова, хвост), где хвост - последний компонент пути, а голова - всё остальное. \n",
297 | "#Хвост никогда не начинается со слеша (если путь заканчивается слешем, то хвост пустой).\n",
298 | "#Если слешей в пути нет, то пустой будет голова."
299 | ]
300 | },
301 | {
302 | "cell_type": "markdown",
303 | "metadata": {
304 | "colab_type": "text",
305 | "id": "ovviRXtCSGC8"
306 | },
307 | "source": [
308 | "**А также:**\n",
309 | "1. [shutil](https://www.journaldev.com/20536/python-shutil-module)\n",
310 | "(модуль для работы с файлами, их копирования, перемещения, удаления и тд)\n",
311 | "\n",
312 | "2. [piclke](https://www.datacamp.com/community/tutorials/pickle-python-tutorial) (модуль для сохранения и загрузки объектов)\n"
313 | ]
314 | },
315 | {
316 | "cell_type": "markdown",
317 | "metadata": {
318 | "colab_type": "text",
319 | "id": "pilnXnWUAgaI"
320 | },
321 | "source": [
322 | "## загрузка данных в колаб"
323 | ]
324 | },
325 | {
326 | "cell_type": "markdown",
327 | "metadata": {
328 | "colab_type": "text",
329 | "id": "hrWIEDeAAkQ_"
330 | },
331 | "source": [
332 | "в колабе есть смециальный модуль ```google.colab```, который позволяет загрузить файлы с компьютера. Вызовем его:"
333 | ]
334 | },
335 | {
336 | "cell_type": "code",
337 | "execution_count": null,
338 | "metadata": {
339 | "colab": {
340 | "base_uri": "https://localhost:8080/",
341 | "height": 344
342 | },
343 | "colab_type": "code",
344 | "id": "vpNBfG9oEo9c",
345 | "outputId": "72f37d0a-6ca7-41a0-9c02-8332fa36087c",
346 | "tags": []
347 | },
348 | "outputs": [],
349 | "source": [
350 | "from google.colab import files #строка импорта\n",
351 | "files.upload() # откроется окно загрузки"
352 | ]
353 | },
354 | {
355 | "cell_type": "code",
356 | "execution_count": null,
357 | "metadata": {
358 | "colab": {
359 | "base_uri": "https://localhost:8080/",
360 | "height": 34
361 | },
362 | "colab_type": "code",
363 | "id": "Nzc6W_CkFBSC",
364 | "outputId": "8b1843b2-8c29-4451-a324-88e5eee14efa"
365 | },
366 | "outputs": [],
367 | "source": [
368 | "os.listdir() #проверяем, что файл действительно на месте"
369 | ]
370 | },
371 | {
372 | "cell_type": "markdown",
373 | "metadata": {
374 | "colab_type": "text",
375 | "id": "B1WOL-zjAFKU"
376 | },
377 | "source": [
378 | "## работа с файлами\n",
379 | "\n",
380 | "Мы оказались в нужной директории, нашли нужный файл. Давайте его прочитаем"
381 | ]
382 | },
383 | {
384 | "cell_type": "code",
385 | "execution_count": null,
386 | "metadata": {
387 | "colab": {},
388 | "colab_type": "code",
389 | "id": "_f5fP_CX91RK",
390 | "tags": []
391 | },
392 | "outputs": [],
393 | "source": [
394 | "with open(\"city_smells.txt\", \"r\") as file: # воспользуемся встроенной функцией open()\n",
395 | " pass"
396 | ]
397 | },
398 | {
399 | "cell_type": "markdown",
400 | "metadata": {
401 | "colab_type": "text",
402 | "id": "AM7jQ6BKGtNQ"
403 | },
404 | "source": [
405 | "давайте посмотрим на аргументы функции: \n",
406 | "* первый = путь к файлу, который хотим открыть.\n",
407 | "\n",
408 | "* второй аргумент - это режим открытия файла: для чтения, записи, дозаписи, все вместе и тд. \n",
409 | "\n",
410 | "\n",
411 | "| Режим | Обозначение |
| 'r' | открытие на чтение (является значением по умолчанию). |
| 'w' | открытие на запись, содержимое файла удаляется, если файла не существует, создается новый. |
| 'x' | открытие на запись, если файла не существует, иначе исключение. |
| 'a' | открытие на дозапись, информация добавляется в конец файла. |
| 'b' | открытие в двоичном режиме. |
| 't' | открытие в текстовом режиме (является значением по умолчанию). |
| '+' | открытие на чтение и запись |
![](\"https://i.redd.it/5j65d9naeww21.png\")
"
326 | ]
327 | },
328 | {
329 | "cell_type": "code",
330 | "execution_count": null,
331 | "metadata": {},
332 | "outputs": [],
333 | "source": []
334 | }
335 | ],
336 | "metadata": {
337 | "colab": {
338 | "collapsed_sections": [],
339 | "include_colab_link": true,
340 | "name": "26oct_19.ipynb",
341 | "provenance": []
342 | },
343 | "kernelspec": {
344 | "display_name": "Python 3",
345 | "language": "python",
346 | "name": "python3"
347 | },
348 | "language_info": {
349 | "codemirror_mode": {
350 | "name": "ipython",
351 | "version": 3
352 | },
353 | "file_extension": ".py",
354 | "mimetype": "text/x-python",
355 | "name": "python",
356 | "nbconvert_exporter": "python",
357 | "pygments_lexer": "ipython3",
358 | "version": "3.8.2"
359 | }
360 | },
361 | "nbformat": 4,
362 | "nbformat_minor": 4
363 | }
364 |
--------------------------------------------------------------------------------
/notebooks/intro_to_OOP.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "id": "3PK6XiSZiGEE"
7 | },
8 | "source": [
9 | "## Введение в ООП в питоне\n",
10 | "\n",
11 | "ООП (объектно-ориентированное программирование) -- это парадигма, которая фокусируется на создании кода как набора взаимосвязанных \"блоков\" и описании их работы. \n",
12 | "\n",
13 | "Два основных термина в парадигме ООП -- это объекты и классы. Классы -- это такие \"шаблоны\", по которым создаются объекты *(представьте план построения дома и готовый дом)*\n",
14 | "\n",
15 | "Объекты удобны, потому что ими можно управлять, масштабировать и изменять при необходимости \n",
16 | "\n",
17 | "Чтобы создать объект, сначала нужен его \"шаблон\", класс. Класс описывает, что объект умеет делать и какими характеристиками обладает.\n",
18 | "\n",
19 | "Объект -- это некоторая абстракция, объектом может быть что угодно. Например, виртуальный котик.\n",
20 | "\n",
21 | "Давайте создадим класс, который опишет его умения и характеристики:\n",
22 | "\n"
23 | ]
24 | },
25 | {
26 | "cell_type": "code",
27 | "execution_count": null,
28 | "metadata": {
29 | "id": "93tj76rHiGEV"
30 | },
31 | "outputs": [],
32 | "source": [
33 | "# Simple Virtual Cat\n",
34 | "# Demonstrates a basic class and object\n",
35 | "\n",
36 | "#создаем класс:\n",
37 | "class Cat(object): # в скобках указывается класс-родитель, или универсальный встроенный тип object\n",
38 | " \"\"\"A virtual pet\"\"\" # здесь идет документация класса, какого рода объекты можно создавать с помощью класса\n",
39 | " \n",
40 | " # самое время определить методы (= что объекты этого класса смогут делать). Метод = функция, принадлежащая объекту\n",
41 | "\n",
42 | " # первый навык \n",
43 | " def talk(self): # объявляем метод\n",
44 | "\n",
45 | " print(\"\\nHi. I'm an instance of class Cat.\\n\")\n",
46 | "\n",
47 | " # return # методы могут что-то возвращать, при необходимости\n",
48 | "\n",
49 | " # второй навык \n",
50 | " def sleep(self):\n",
51 | " # try:\n",
52 | " # x = float(input('insert a number:')) # условие, напишем через try-except чтобы исключить неверные типы ввода\n",
53 | " # print(\"\\nI'm off to sleep for\", x, \"hours, bye!\\n\") #what to do if no exceptions arise\n",
54 | " # except:\n",
55 | " # print('\\nthis is not a number, I need a number\\n') # ветка для ситуаций, если пользователь ввел не число\n",
56 | " print(\"*sleeping*\") #what to do if no exceptions arise\n",
57 | " \n",
58 | " "
59 | ]
60 | },
61 | {
62 | "cell_type": "markdown",
63 | "metadata": {
64 | "id": "RZe8SQxy7Akj"
65 | },
66 | "source": [
67 | "ссылочка на try-except"
68 | ]
69 | },
70 | {
71 | "cell_type": "markdown",
72 | "metadata": {
73 | "id": "7GT5nQqmcWbT"
74 | },
75 | "source": [
76 | "**про self** \n",
77 | "\n",
78 | "Как первый параметр любого метода, self автоматически\n",
79 | "становится ссылкой на объект, по отношению к которому вызван\n",
80 | "метод. Это значит, что через self метод получает доступ к вызывающему объекту,\n",
81 | "к его атрибутам и методам (он может, в частности, создавать у объекта новые атрибуты).\n",
82 | "\n",
83 | "Мы прописали два начальных метода для класса. Теперь все котики (=объекты), созданные от этого класса, будут уметь говорить (```.talk()```) и спать(```.sleep()```)\n",
84 | "\n",
85 | "Самое время создать первый объект:"
86 | ]
87 | },
88 | {
89 | "cell_type": "code",
90 | "execution_count": null,
91 | "metadata": {
92 | "colab": {
93 | "base_uri": "https://localhost:8080/"
94 | },
95 | "id": "DzKmQF-DiGFI",
96 | "outputId": "2d435b45-ff94-43d7-bf61-5b6433f8882a"
97 | },
98 | "outputs": [
99 | {
100 | "name": "stdout",
101 | "output_type": "stream",
102 | "text": [
103 | "\n",
104 | "Hi. I'm an instance of class Cat.\n",
105 | "\n"
106 | ]
107 | }
108 | ],
109 | "source": [
110 | "# создаем объект класса Cat, сохраняем в какую-нибудь переменную\n",
111 | "gatto = Cat()\n",
112 | "\n",
113 | "# у этого объекта есть все методы родительского класса \n",
114 | "gatto.talk()"
115 | ]
116 | },
117 | {
118 | "cell_type": "code",
119 | "execution_count": null,
120 | "metadata": {
121 | "colab": {
122 | "base_uri": "https://localhost:8080/"
123 | },
124 | "id": "0elZeUIydU3I",
125 | "outputId": "45052153-47ca-4846-9762-9263d39e441b"
126 | },
127 | "outputs": [
128 | {
129 | "name": "stdout",
130 | "output_type": "stream",
131 | "text": [
132 | "*sleeping*\n"
133 | ]
134 | }
135 | ],
136 | "source": [
137 | "gatto.sleep()"
138 | ]
139 | },
140 | {
141 | "cell_type": "markdown",
142 | "metadata": {
143 | "id": "VnZldnosiGF5"
144 | },
145 | "source": [
146 | "### метод-конструктор aka метод ```__init__``` (метод инициализации)\n",
147 | "\n",
148 | "Иногда методы удобно вызывать не вручную, а сразу при создании нового объекта (обычно это нужно, чтобы установить начальные значения атрибутов объекта) ![](\"https://imgs.xkcd.com/comics/regular_expressions.png\")
"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {
30 | "colab_type": "text",
31 | "id": "HJoXkRLhKEvv"
32 | },
33 | "source": [
34 | "регулярные выражения можно использовать не только в питоне! Можно везде, где поддерживается их синтаксис