├── Coursera DSKT344R2FC2.pdf ├── Python_FAQ.pdf ├── README.md ├── conspect ├── 1-1.Vvedenie.pdf ├── 1-2.Programmirovanie_na_Python.pdf ├── 1-3.Osnovy-matematicheskogo-analiza.pdf ├── 2-1.Znakomstvo-s-linejnoj-algebroj.pdf ├── 2-2.Matricy_i_osnovnye_matrichnye_operacii.pdf ├── 3-1.Funkcii-mnogih-peremennyh.pdf ├── 3-2.Metody_optimizacii.pdf ├── 3-3.Singulyarnoe_razlozhenie_matric.pdf ├── 4-1.Veroyatnost_-i-sluchajnye-velichiny.pdf ├── 4-2.Statistiki.pdf └── Finctions and generators.pdf ├── interesting_links ├── week1 ├── 2. 1. Introduction to Python (On Python 2).ipynb ├── 2.2. Data types (Python 2).ipynb ├── 2.3. Finctions and generators.ipynb ├── 2.4. Reading from files (Python 2).ipynb ├── 3.1. Introduction to Python (On Python 3).ipynb ├── 3.4. Reading from files (Python 3).ipynb ├── Untitled.ipynb ├── Writing to files (Python 2).ipynb ├── example_koi_8.txt ├── example_utf8.txt ├── file_to_write_in.txt ├── from authors │ ├── Types_in_Python.ipynb │ ├── example_koi_8.txt │ ├── example_utf8.txt │ ├── introduction_to_ipython.ipynb │ ├── ipython_files_data_reading.ipynb │ └── ipython_files_data_writing.ipynb └── second_file_for_write_in.txt ├── week2 ├── Matrix operations (Python 2).ipynb ├── NumPy, SciPy, Matplotlib intro (Python 2).ipynb ├── Pandas DataFrame (Python 2).ipynb ├── Polynome approximation (Python 3).ipynb ├── SciPy_Optimization (Python 2).ipynb ├── Vector Operations (Python 2).ipynb ├── cat_work (Python 3).ipynb ├── data_sample_example.tsv ├── dataset.tsv ├── from authors │ ├── NumPy_-SciPy_-Matplotlib-intro.ipynb │ ├── Pandas Indexing and Selection (Python 2).ipynb │ ├── data_sample_example.tsv │ ├── dataset.tsv │ ├── pandas_dataframe.ipynb │ ├── pandas_indexing_selection.ipynb │ └── vector_operations.ipynb ├── sentences.txt └── updated_dataset.csv ├── week3 ├── Optimization of non-smooth functions.ipynb ├── submission-1.txt ├── submission-2.txt └── submission-3.txt ├── week4 ├── Central limit theorem.ipynb ├── Check │ ├── cpt.ipynb │ ├── mynotebook.ipynb │ ├── third_prog_quest.ipynb │ └── Центральная предельная теорема своими руками.ipynb ├── Empirical distribution function.ipynb ├── Random variables and distributions.ipynb ├── Sample distribution evaluation.ipynb ├── bonus │ ├── wine.csv │ └── wine.ipynb └── from_authors │ ├── sample_distribution_evaluation.ipynb │ └── stochastic_variables.ipynb └── Дополнительные материалы ├── FixedNorm (Python 2).ipynb ├── linalg12.pdf ├── stochastic_variables.txt └── квартет.PNG /Coursera DSKT344R2FC2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/Coursera DSKT344R2FC2.pdf -------------------------------------------------------------------------------- /Python_FAQ.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/Python_FAQ.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MathAndPythonForDataAnalysis 2 | 3 | Ссылка на сертификат 4 | https://www.coursera.org/account/accomplishments/records/DSKT344R2FC2 5 | 6 | Репозиторий для материалов и задач курса "Математика и Python для анализа данных" от МФТИ и Яндекса, платформа Coursera. Это первый цикл специализации "Машинное обучение и анализ данных"" 7 | 8 | from__future__ import print_function # print как функция Python 2 9 | from __future__ import division 10 | import gc 11 | gc.collect() 12 | 13 | 14 | objects = [1, 2, 1, 5, True, False, True, 'false', [], [1,2], [1,2]] 15 | 16 | https://pythonworld.ru/osnovy/python2-vs-python3-razlichiya-sintaksisa.html 17 | 18 | https://habr.com/ru/post/112953/ 19 | -------------------------------------------------------------------------------- /conspect/1-1.Vvedenie.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/1-1.Vvedenie.pdf -------------------------------------------------------------------------------- /conspect/1-2.Programmirovanie_na_Python.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/1-2.Programmirovanie_na_Python.pdf -------------------------------------------------------------------------------- /conspect/1-3.Osnovy-matematicheskogo-analiza.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/1-3.Osnovy-matematicheskogo-analiza.pdf -------------------------------------------------------------------------------- /conspect/2-1.Znakomstvo-s-linejnoj-algebroj.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/2-1.Znakomstvo-s-linejnoj-algebroj.pdf -------------------------------------------------------------------------------- /conspect/2-2.Matricy_i_osnovnye_matrichnye_operacii.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/2-2.Matricy_i_osnovnye_matrichnye_operacii.pdf -------------------------------------------------------------------------------- /conspect/3-1.Funkcii-mnogih-peremennyh.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/3-1.Funkcii-mnogih-peremennyh.pdf -------------------------------------------------------------------------------- /conspect/3-2.Metody_optimizacii.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/3-2.Metody_optimizacii.pdf -------------------------------------------------------------------------------- /conspect/3-3.Singulyarnoe_razlozhenie_matric.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/3-3.Singulyarnoe_razlozhenie_matric.pdf -------------------------------------------------------------------------------- /conspect/4-1.Veroyatnost_-i-sluchajnye-velichiny.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/4-1.Veroyatnost_-i-sluchajnye-velichiny.pdf -------------------------------------------------------------------------------- /conspect/4-2.Statistiki.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/4-2.Statistiki.pdf -------------------------------------------------------------------------------- /conspect/Finctions and generators.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/conspect/Finctions and generators.pdf -------------------------------------------------------------------------------- /interesting_links: -------------------------------------------------------------------------------- 1 | https://www.autodeskresearch.com/publications/samestats (датазавр и его друзья) 2 | 3 | https://mathwithbaddrawings.com/2016/07/13/why-not-to-trust-statistics/ (комикс) 4 | 5 | -------------------------------------------------------------------------------- /week1/2. 1. Introduction to Python (On Python 2).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Hello, world!\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "print \"Hello, world!\"" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 4, 23 | "metadata": {}, 24 | "outputs": [ 25 | { 26 | "data": { 27 | "text/plain": [ 28 | "'1.16.3'" 29 | ] 30 | }, 31 | "execution_count": 4, 32 | "metadata": {}, 33 | "output_type": "execute_result" 34 | } 35 | ], 36 | "source": [ 37 | "import numpy\n", 38 | "numpy.__version__" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 5, 44 | "metadata": {}, 45 | "outputs": [ 46 | { 47 | "data": { 48 | "text/plain": [ 49 | "8" 50 | ] 51 | }, 52 | "execution_count": 5, 53 | "metadata": {}, 54 | "output_type": "execute_result" 55 | } 56 | ], 57 | "source": [ 58 | "100 / 12" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 6, 64 | "metadata": {}, 65 | "outputs": [ 66 | { 67 | "data": { 68 | "text/plain": [ 69 | "8.333333333333334" 70 | ] 71 | }, 72 | "execution_count": 6, 73 | "metadata": {}, 74 | "output_type": "execute_result" 75 | } 76 | ], 77 | "source": [ 78 | "100. / 12" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 7, 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "8.333333" 90 | ] 91 | }, 92 | "execution_count": 7, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "#Округление до количества точек после запятой\n", 99 | "round(100. / 12, 6)" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 10, 105 | "metadata": {}, 106 | "outputs": [], 107 | "source": [ 108 | "# импорт функции из стандартной библиотеки\n", 109 | "from math import factorial" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 11, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "data": { 119 | "text/plain": [ 120 | "720" 121 | ] 122 | }, 123 | "execution_count": 11, 124 | "metadata": {}, 125 | "output_type": "execute_result" 126 | } 127 | ], 128 | "source": [ 129 | "factorial(6)" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 12, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "data": { 139 | "text/plain": [ 140 | "1814400.0" 141 | ] 142 | }, 143 | "execution_count": 12, 144 | "metadata": {}, 145 | "output_type": "execute_result" 146 | } 147 | ], 148 | "source": [ 149 | "factorial(10)*0.5" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "Markdown cell" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "# Header \n", 164 | "Сколько решеток, такой уровень у заголовка (одна решетка - заголовок первого уровня).\n", 165 | "\n", 166 | "# Ввод формул Latex\n", 167 | "Далее ввод формулы Latex (два символа доллара $$)" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "$$ c = \\sqrt{a^2 + b^2} $$" 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "Есть возможность вызывать bash или консоль прямо из ноутбука, а также передавать туда переменные (знак доллара $ и имя переменной):" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 3, 187 | "metadata": {}, 188 | "outputs": [ 189 | { 190 | "name": "stdout", 191 | "output_type": "stream", 192 | "text": [ 193 | "\"Hello, world!\"\n" 194 | ] 195 | } 196 | ], 197 | "source": [ 198 | "! echo \"Hello, world!\"" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 4, 204 | "metadata": {}, 205 | "outputs": [ 206 | { 207 | "name": "stdout", 208 | "output_type": "stream", 209 | "text": [ 210 | "Hello, world!\n" 211 | ] 212 | } 213 | ], 214 | "source": [ 215 | "t = 'Hello, world!'\n", 216 | "! echo $t" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "## Cell magic\n", 224 | "\n", 225 | "Вызов терминала с набором нескольких команд (не забываем сменить кодировку): " 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 5, 231 | "metadata": {}, 232 | "outputs": [ 233 | { 234 | "name": "stdout", 235 | "output_type": "stream", 236 | "text": [ 237 | "Microsoft Windows [Version 6.1.7601]\r\n", 238 | "Copyright (c) 2009 Microsoft Corporation. All rights reserved.\r\n", 239 | "\r\n", 240 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>chcp 65001\n", 241 | "Active code page: 65001\r\n", 242 | "\r\n", 243 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>cd ..\n", 244 | "\r\n", 245 | "(py27) C:\\Users\\GLFS\\mathandpython>dir\n", 246 | " Volume in drive C has no label.\r\n", 247 | " Volume Serial Number is B009-5793\r\n", 248 | "\r\n", 249 | " Directory of C:\\Users\\GLFS\\mathandpython\r\n", 250 | "\r\n", 251 | "10.08.2019 12:40 .\r\n", 252 | "10.08.2019 12:40 ..\r\n", 253 | "16.08.2019 12:59 conspect\r\n", 254 | "16.08.2019 21:57 week1\r\n", 255 | " 0 File(s) 0 bytes\r\n", 256 | " 4 Dir(s) 442 176 454 656 bytes free\r\n", 257 | "\r\n", 258 | "(py27) C:\\Users\\GLFS\\mathandpython>" 259 | ] 260 | } 261 | ], 262 | "source": [ 263 | "%%cmd\n", 264 | "chcp 65001\n", 265 | "cd ..\n", 266 | "dir" 267 | ] 268 | }, 269 | { 270 | "cell_type": "markdown", 271 | "metadata": {}, 272 | "source": [ 273 | "## Список команд cell magic" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": 22, 279 | "metadata": {}, 280 | "outputs": [ 281 | { 282 | "data": { 283 | "application/json": { 284 | "cell": { 285 | "!": "OSMagics", 286 | "HTML": "Other", 287 | "SVG": "Other", 288 | "bash": "Other", 289 | "capture": "ExecutionMagics", 290 | "cmd": "Other", 291 | "debug": "ExecutionMagics", 292 | "file": "Other", 293 | "html": "DisplayMagics", 294 | "javascript": "DisplayMagics", 295 | "js": "DisplayMagics", 296 | "latex": "DisplayMagics", 297 | "perl": "Other", 298 | "prun": "ExecutionMagics", 299 | "pypy": "Other", 300 | "python": "Other", 301 | "python2": "Other", 302 | "python3": "Other", 303 | "ruby": "Other", 304 | "script": "ScriptMagics", 305 | "sh": "Other", 306 | "svg": "DisplayMagics", 307 | "sx": "OSMagics", 308 | "system": "OSMagics", 309 | "time": "ExecutionMagics", 310 | "timeit": "ExecutionMagics", 311 | "writefile": "OSMagics" 312 | }, 313 | "line": { 314 | "alias": "OSMagics", 315 | "alias_magic": "BasicMagics", 316 | "autocall": "AutoMagics", 317 | "automagic": "AutoMagics", 318 | "autosave": "KernelMagics", 319 | "bookmark": "OSMagics", 320 | "cd": "OSMagics", 321 | "clear": "KernelMagics", 322 | "cls": "KernelMagics", 323 | "colors": "BasicMagics", 324 | "config": "ConfigMagics", 325 | "connect_info": "KernelMagics", 326 | "copy": "Other", 327 | "ddir": "Other", 328 | "debug": "ExecutionMagics", 329 | "dhist": "OSMagics", 330 | "dirs": "OSMagics", 331 | "doctest_mode": "BasicMagics", 332 | "echo": "Other", 333 | "ed": "Other", 334 | "edit": "KernelMagics", 335 | "env": "OSMagics", 336 | "gui": "BasicMagics", 337 | "hist": "Other", 338 | "history": "HistoryMagics", 339 | "killbgscripts": "ScriptMagics", 340 | "ldir": "Other", 341 | "less": "KernelMagics", 342 | "load": "CodeMagics", 343 | "load_ext": "ExtensionMagics", 344 | "loadpy": "CodeMagics", 345 | "logoff": "LoggingMagics", 346 | "logon": "LoggingMagics", 347 | "logstart": "LoggingMagics", 348 | "logstate": "LoggingMagics", 349 | "logstop": "LoggingMagics", 350 | "ls": "Other", 351 | "lsmagic": "BasicMagics", 352 | "macro": "ExecutionMagics", 353 | "magic": "BasicMagics", 354 | "matplotlib": "PylabMagics", 355 | "mkdir": "Other", 356 | "more": "KernelMagics", 357 | "notebook": "BasicMagics", 358 | "page": "BasicMagics", 359 | "pastebin": "CodeMagics", 360 | "pdb": "ExecutionMagics", 361 | "pdef": "NamespaceMagics", 362 | "pdoc": "NamespaceMagics", 363 | "pfile": "NamespaceMagics", 364 | "pinfo": "NamespaceMagics", 365 | "pinfo2": "NamespaceMagics", 366 | "popd": "OSMagics", 367 | "pprint": "BasicMagics", 368 | "precision": "BasicMagics", 369 | "profile": "BasicMagics", 370 | "prun": "ExecutionMagics", 371 | "psearch": "NamespaceMagics", 372 | "psource": "NamespaceMagics", 373 | "pushd": "OSMagics", 374 | "pwd": "OSMagics", 375 | "pycat": "OSMagics", 376 | "pylab": "PylabMagics", 377 | "qtconsole": "KernelMagics", 378 | "quickref": "BasicMagics", 379 | "recall": "HistoryMagics", 380 | "rehashx": "OSMagics", 381 | "reload_ext": "ExtensionMagics", 382 | "ren": "Other", 383 | "rep": "Other", 384 | "rerun": "HistoryMagics", 385 | "reset": "NamespaceMagics", 386 | "reset_selective": "NamespaceMagics", 387 | "rmdir": "Other", 388 | "run": "ExecutionMagics", 389 | "save": "CodeMagics", 390 | "sc": "OSMagics", 391 | "set_env": "OSMagics", 392 | "store": "StoreMagics", 393 | "sx": "OSMagics", 394 | "system": "OSMagics", 395 | "tb": "ExecutionMagics", 396 | "time": "ExecutionMagics", 397 | "timeit": "ExecutionMagics", 398 | "unalias": "OSMagics", 399 | "unload_ext": "ExtensionMagics", 400 | "who": "NamespaceMagics", 401 | "who_ls": "NamespaceMagics", 402 | "whos": "NamespaceMagics", 403 | "xdel": "NamespaceMagics", 404 | "xmode": "BasicMagics" 405 | } 406 | }, 407 | "text/plain": [ 408 | "Available line magics:\n", 409 | "%alias %alias_magic %autocall %automagic %autosave %bookmark %cd %clear %cls %colors %config %connect_info %copy %ddir %debug %dhist %dirs %doctest_mode %echo %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %macro %magic %matplotlib %mkdir %more %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %ren %rep %rerun %reset %reset_selective %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode\n", 410 | "\n", 411 | "Available cell magics:\n", 412 | "%%! %%HTML %%SVG %%bash %%capture %%cmd %%debug %%file %%html %%javascript %%js %%latex %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefile\n", 413 | "\n", 414 | "Automagic is ON, % prefix IS NOT needed for line magics." 415 | ] 416 | }, 417 | "execution_count": 22, 418 | "metadata": {}, 419 | "output_type": "execute_result" 420 | } 421 | ], 422 | "source": [ 423 | "%lsmagic" 424 | ] 425 | }, 426 | { 427 | "cell_type": "markdown", 428 | "metadata": {}, 429 | "source": [ 430 | "## Работа с графикой pylab" 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": 24, 436 | "metadata": {}, 437 | "outputs": [ 438 | { 439 | "name": "stdout", 440 | "output_type": "stream", 441 | "text": [ 442 | "Populating the interactive namespace from numpy and matplotlib\n" 443 | ] 444 | } 445 | ], 446 | "source": [ 447 | "%pylab inline" 448 | ] 449 | }, 450 | { 451 | "cell_type": "code", 452 | "execution_count": 25, 453 | "metadata": {}, 454 | "outputs": [ 455 | { 456 | "name": "stdout", 457 | "output_type": "stream", 458 | "text": [ 459 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n" 460 | ] 461 | }, 462 | { 463 | "data": { 464 | "text/plain": [ 465 | "[]" 466 | ] 467 | }, 468 | "execution_count": 25, 469 | "metadata": {}, 470 | "output_type": "execute_result" 471 | }, 472 | { 473 | "data": { 474 | "image/png": "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\n", 475 | "text/plain": [ 476 | "
" 477 | ] 478 | }, 479 | "metadata": { 480 | "needs_background": "light" 481 | }, 482 | "output_type": "display_data" 483 | } 484 | ], 485 | "source": [ 486 | "y = range(11)\n", 487 | "print(y)\n", 488 | "plot(y)" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": 26, 494 | "metadata": {}, 495 | "outputs": [ 496 | { 497 | "data": { 498 | "text/plain": [ 499 | "'1.16.3'" 500 | ] 501 | }, 502 | "execution_count": 26, 503 | "metadata": {}, 504 | "output_type": "execute_result" 505 | } 506 | ], 507 | "source": [ 508 | "import numpy\n", 509 | "numpy.__version__" 510 | ] 511 | }, 512 | { 513 | "cell_type": "code", 514 | "execution_count": 27, 515 | "metadata": {}, 516 | "outputs": [ 517 | { 518 | "data": { 519 | "text/plain": [ 520 | "'1.2.1'" 521 | ] 522 | }, 523 | "execution_count": 27, 524 | "metadata": {}, 525 | "output_type": "execute_result" 526 | } 527 | ], 528 | "source": [ 529 | "import scipy\n", 530 | "scipy.__version__" 531 | ] 532 | }, 533 | { 534 | "cell_type": "code", 535 | "execution_count": 28, 536 | "metadata": {}, 537 | "outputs": [ 538 | { 539 | "data": { 540 | "text/plain": [ 541 | "u'0.24.2'" 542 | ] 543 | }, 544 | "execution_count": 28, 545 | "metadata": {}, 546 | "output_type": "execute_result" 547 | } 548 | ], 549 | "source": [ 550 | "import pandas\n", 551 | "pandas.__version__" 552 | ] 553 | }, 554 | { 555 | "cell_type": "code", 556 | "execution_count": 29, 557 | "metadata": {}, 558 | "outputs": [ 559 | { 560 | "data": { 561 | "text/plain": [ 562 | "'2.2.3'" 563 | ] 564 | }, 565 | "execution_count": 29, 566 | "metadata": {}, 567 | "output_type": "execute_result" 568 | } 569 | ], 570 | "source": [ 571 | "import matplotlib\n", 572 | "matplotlib.__version__" 573 | ] 574 | }, 575 | { 576 | "cell_type": "markdown", 577 | "metadata": {}, 578 | "source": [ 579 | "# Машинное обучение и анализ данных\n", 580 | "## Математика и Python\n", 581 | "Задание 1" 582 | ] 583 | }, 584 | { 585 | "cell_type": "code", 586 | "execution_count": null, 587 | "metadata": {}, 588 | "outputs": [], 589 | "source": [] 590 | } 591 | ], 592 | "metadata": { 593 | "kernelspec": { 594 | "display_name": "Python 2", 595 | "language": "python", 596 | "name": "python2" 597 | }, 598 | "language_info": { 599 | "codemirror_mode": { 600 | "name": "ipython", 601 | "version": 2 602 | }, 603 | "file_extension": ".py", 604 | "mimetype": "text/x-python", 605 | "name": "python", 606 | "nbconvert_exporter": "python", 607 | "pygments_lexer": "ipython2", 608 | "version": "2.7.16" 609 | } 610 | }, 611 | "nbformat": 4, 612 | "nbformat_minor": 2 613 | } 614 | -------------------------------------------------------------------------------- /week1/2.3. Finctions and generators.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Для того, чтобы print не переводил каретку, необходимо написать запятую" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 2, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "0 1 2 3 4\n" 20 | ] 21 | } 22 | ], 23 | "source": [ 24 | "for i in range(5):\n", 25 | " print i," 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "## range и xrange отличаются (в Python 2)" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 4, 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "name": "stdout", 42 | "output_type": "stream", 43 | "text": [ 44 | "\n", 45 | "\n" 46 | ] 47 | } 48 | ], 49 | "source": [ 50 | "print type(range(5))\n", 51 | "print type(xrange(5))" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "## xrange - генератор (на лету)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "## list comprehension" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 5, 71 | "metadata": {}, 72 | "outputs": [ 73 | { 74 | "name": "stdout", 75 | "output_type": "stream", 76 | "text": [ 77 | "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" 78 | ] 79 | } 80 | ], 81 | "source": [ 82 | "print [x**2 for x in range(1, 11)]" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 6, 88 | "metadata": {}, 89 | "outputs": [ 90 | { 91 | "name": "stdout", 92 | "output_type": "stream", 93 | "text": [ 94 | "[4, 16, 36, 64, 100]\n" 95 | ] 96 | } 97 | ], 98 | "source": [ 99 | "print [x**2 for x in range(1, 11) if x % 2 == 0]" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 8, 105 | "metadata": {}, 106 | "outputs": [ 107 | { 108 | "name": "stdout", 109 | "output_type": "stream", 110 | "text": [ 111 | "\n" 112 | ] 113 | } 114 | ], 115 | "source": [ 116 | "w = [x**2 for x in range(1, 11) if x % 2 == 0]\n", 117 | "print(type(w))" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "## А как сделать не лист, а генератор?\n", 125 | "#### Заменить квадратные скобки на круглые" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 10, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "name": "stdout", 135 | "output_type": "stream", 136 | "text": [ 137 | "\n" 138 | ] 139 | } 140 | ], 141 | "source": [ 142 | "w = (x**2 for x in range(1, 11) if x % 2 == 0)\n", 143 | "print type(w)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "## Функции" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 12, 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "data": { 160 | "text/plain": [ 161 | "[1, 2, 3, 4]" 162 | ] 163 | }, 164 | "execution_count": 12, 165 | "metadata": {}, 166 | "output_type": "execute_result" 167 | } 168 | ], 169 | "source": [ 170 | "def myrange(a, b):\n", 171 | " res = []\n", 172 | " s = a\n", 173 | " while s != b:\n", 174 | " res.append(s)\n", 175 | " s += 1\n", 176 | " return res\n", 177 | "myrange(1, 5)\n", 178 | " " 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "## Функция map\n", 186 | "### Применяет некоторую функцию к контейнеру" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 14, 192 | "metadata": {}, 193 | "outputs": [ 194 | { 195 | "name": "stdout", 196 | "output_type": "stream", 197 | "text": [ 198 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "print [x ** 2 for x in range(11)]" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 15, 209 | "metadata": {}, 210 | "outputs": [ 211 | { 212 | "name": "stdout", 213 | "output_type": "stream", 214 | "text": [ 215 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" 216 | ] 217 | } 218 | ], 219 | "source": [ 220 | "def sq(x):\n", 221 | " return x ** 2\n", 222 | "print map(sq, range(11))" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": 17, 228 | "metadata": {}, 229 | "outputs": [ 230 | { 231 | "name": "stdout", 232 | "output_type": "stream", 233 | "text": [ 234 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" 235 | ] 236 | } 237 | ], 238 | "source": [ 239 | "## Тоже самое с lambda\n", 240 | "print map(lambda x: x**2 , range(11)) # можно дописать больше переменных через запятую после x" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [] 249 | } 250 | ], 251 | "metadata": { 252 | "kernelspec": { 253 | "display_name": "Python 2", 254 | "language": "python", 255 | "name": "python2" 256 | }, 257 | "language_info": { 258 | "codemirror_mode": { 259 | "name": "ipython", 260 | "version": 2 261 | }, 262 | "file_extension": ".py", 263 | "mimetype": "text/x-python", 264 | "name": "python", 265 | "nbconvert_exporter": "python", 266 | "pygments_lexer": "ipython2", 267 | "version": "2.7.16" 268 | } 269 | }, 270 | "nbformat": 4, 271 | "nbformat_minor": 2 272 | } 273 | -------------------------------------------------------------------------------- /week1/2.4. Reading from files (Python 2).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Чтение данных из файла" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "?open" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 2, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "data": { 26 | "text/plain": [ 27 | "\"file(name[, mode[, buffering]]) -> file object\\n\\nOpen a file. The mode can be 'r', 'w' or 'a' for reading (default),\\nwriting or appending. The file will be created if it doesn't exist\\nwhen opened for writing or appending; it will be truncated when\\nopened for writing. Add a 'b' to the mode for binary files.\\nAdd a '+' to the mode to allow simultaneous reading and writing.\\nIf the buffering argument is given, 0 means unbuffered, 1 means line\\nbuffered, and larger numbers specify the buffer size. The preferred way\\nto open a file is with the builtin open() function.\\nAdd a 'U' to mode to open the file for input with universal newline\\nsupport. Any line ending in the input file will be seen as a '\\\\n'\\nin Python. Also, a file so opened gains the attribute 'newlines';\\nthe value for this attribute is one of None (no newline read yet),\\n'\\\\r', '\\\\n', '\\\\r\\\\n' or a tuple containing all the newline types seen.\\n\\n'U' cannot be combined with 'w' or '+' mode.\\n\"" 28 | ] 29 | }, 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "output_type": "execute_result" 33 | } 34 | ], 35 | "source": [ 36 | "file.__doc__" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 4, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "?sorted" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 5, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "data": { 55 | "text/plain": [ 56 | "'sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list'" 57 | ] 58 | }, 59 | "execution_count": 5, 60 | "metadata": {}, 61 | "output_type": "execute_result" 62 | } 63 | ], 64 | "source": [ 65 | "sorted.__doc__" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 6, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "file_obj = open('example_utf8.txt', 'r')" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 7, 80 | "metadata": {}, 81 | "outputs": [ 82 | { 83 | "data": { 84 | "text/plain": [ 85 | "file" 86 | ] 87 | }, 88 | "execution_count": 7, 89 | "metadata": {}, 90 | "output_type": "execute_result" 91 | } 92 | ], 93 | "source": [ 94 | "type(file_obj)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 8, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "name": "stdout", 104 | "output_type": "stream", 105 | "text": [ 106 | "Привет, мир!\n", 107 | "тестовый файл\n", 108 | "урок \"чтение данных в python\"\n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "print file_obj.read()" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 10, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "?file.read" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 14, 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "name": "stdout", 132 | "output_type": "stream", 133 | "text": [ 134 | "None\n" 135 | ] 136 | } 137 | ], 138 | "source": [ 139 | "print file_obj.close()" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 18, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "Привет, мир!\n", 152 | "\n" 153 | ] 154 | } 155 | ], 156 | "source": [ 157 | "file_obj = open('example_utf8.txt', 'r')\n", 158 | "print file_obj.readline()" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 19, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "тестовый файл\n", 171 | "\n" 172 | ] 173 | } 174 | ], 175 | "source": [ 176 | "print file_obj.readline()" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 20, 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "name": "stdout", 186 | "output_type": "stream", 187 | "text": [ 188 | "урок \"чтение данных в python\"\n" 189 | ] 190 | } 191 | ], 192 | "source": [ 193 | "print file_obj.readline()\\" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 21, 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "\n" 206 | ] 207 | } 208 | ], 209 | "source": [ 210 | "print file_obj.readline()" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 25, 216 | "metadata": {}, 217 | "outputs": [], 218 | "source": [ 219 | "file_obj = open('example_utf8.txt', 'r')" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 26, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "name": "stdout", 229 | "output_type": "stream", 230 | "text": [ 231 | "Привет, мир!\n", 232 | "тестовый файл\n", 233 | "урок \"чтение данных в python\"\n" 234 | ] 235 | } 236 | ], 237 | "source": [ 238 | "for line in file_obj:\n", 239 | " print line.strip()" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 4, 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "name": "stdout", 249 | "output_type": "stream", 250 | "text": [ 251 | "Привет, мир!\n", 252 | "тестовый файл\n", 253 | "урок \"чтение данных в python\"\n" 254 | ] 255 | } 256 | ], 257 | "source": [ 258 | "file_obj = open('example_utf8.txt', 'r')\n", 259 | "data_list = list(file_obj)\n", 260 | "for line in data_list:\n", 261 | " print line.strip()" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 6, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "name": "stdout", 271 | "output_type": "stream", 272 | "text": [ 273 | "Привет, мир!\n", 274 | "тестовый файл\n", 275 | "урок \"чтение данных в python\"\n" 276 | ] 277 | } 278 | ], 279 | "source": [ 280 | "file_obj = open('example_utf8.txt', 'r')\n", 281 | "data_list = file_obj.readlines()\n", 282 | "for line in data_list: print line.strip()" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 7, 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "ename": "ValueError", 292 | "evalue": "I/O operation on closed file", 293 | "output_type": "error", 294 | "traceback": [ 295 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 296 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 297 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mfile_obj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'example_utf8.txt'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mfile_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mfile_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 298 | "\u001b[1;31mValueError\u001b[0m: I/O operation on closed file" 299 | ] 300 | } 301 | ], 302 | "source": [ 303 | "#попытка чтения закрытого файла приводит к ошибке!\n", 304 | "file_obj = open('example_utf8.txt')\n", 305 | "file_obj.close()\n", 306 | "file_obj.read()" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 8, 312 | "metadata": {}, 313 | "outputs": [], 314 | "source": [ 315 | "file_obj = open('example_koi_8.txt')" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 9, 321 | "metadata": {}, 322 | "outputs": [ 323 | { 324 | "name": "stdout", 325 | "output_type": "stream", 326 | "text": [ 327 | "������, ���!\n", 328 | "��� �������� ����\n", 329 | "��������� koi8-r\n", 330 | "���� \"������ ������ � python\"\n" 331 | ] 332 | } 333 | ], 334 | "source": [ 335 | "#вывод на экран файла в кодировке koi8-r\n", 336 | "print file_obj.read()" 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "# Codecs" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": 10, 349 | "metadata": {}, 350 | "outputs": [], 351 | "source": [ 352 | "import codecs" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": 11, 358 | "metadata": {}, 359 | "outputs": [], 360 | "source": [ 361 | "#открытие файла для чтения с помощью функции open модуля codecs с указанием кодировки koi8-r\n", 362 | "file_obj = codecs.open('example_koi_8.txt', 'r', encoding='koi8-r')" 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "execution_count": 12, 368 | "metadata": {}, 369 | "outputs": [ 370 | { 371 | "name": "stdout", 372 | "output_type": "stream", 373 | "text": [ 374 | "Привет, мир!\n", 375 | "Это тестовый файл\n", 376 | "Кодировка koi8-r\n", 377 | "Урок \"чтение данных в python\"\n" 378 | ] 379 | } 380 | ], 381 | "source": [ 382 | "print file_obj.read()" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": null, 388 | "metadata": {}, 389 | "outputs": [], 390 | "source": [] 391 | } 392 | ], 393 | "metadata": { 394 | "kernelspec": { 395 | "display_name": "Python 2", 396 | "language": "python", 397 | "name": "python2" 398 | }, 399 | "language_info": { 400 | "codemirror_mode": { 401 | "name": "ipython", 402 | "version": 2 403 | }, 404 | "file_extension": ".py", 405 | "mimetype": "text/x-python", 406 | "name": "python", 407 | "nbconvert_exporter": "python", 408 | "pygments_lexer": "ipython2", 409 | "version": "2.7.16" 410 | } 411 | }, 412 | "nbformat": 4, 413 | "nbformat_minor": 2 414 | } 415 | -------------------------------------------------------------------------------- /week1/3.1. Introduction to Python (On Python 3).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "data": { 10 | "text/plain": [ 11 | "8.333333333333334" 12 | ] 13 | }, 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "output_type": "execute_result" 17 | } 18 | ], 19 | "source": [ 20 | "100 / 12" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "8" 32 | ] 33 | }, 34 | "execution_count": 2, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "round(100 /12)" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 4, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "name": "stdout", 50 | "output_type": "stream", 51 | "text": [ 52 | "hello world\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "t = 'hello world'\n", 58 | "print(t)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 5, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "# импорт функции из стандартной библиотеки\n", 68 | "from math import factorial" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 6, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "1814400.0" 80 | ] 81 | }, 82 | "execution_count": 6, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "factorial(10)*0.5" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "# Header \n", 96 | "Сколько решеток, такой уровень у заголовка (одна решетка - заголовок первого уровня).\n", 97 | "\n", 98 | "# Ввод формул Latex\n", 99 | "Далее ввод формулы Latex (два символа доллара $$)" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "$$ c = \\sqrt{a^2 + b^2} $$" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "Есть возможность вызывать bash или консоль прямо из ноутбука, а также передавать туда переменные (знак доллара $ и имя переменной):" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 7, 119 | "metadata": {}, 120 | "outputs": [ 121 | { 122 | "name": "stdout", 123 | "output_type": "stream", 124 | "text": [ 125 | "\"Hello, world!\"\n" 126 | ] 127 | } 128 | ], 129 | "source": [ 130 | "! echo \"Hello, world!\"" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 8, 136 | "metadata": {}, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "Hello, world!\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "t = 'Hello, world!'\n", 148 | "! echo $t" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "## Cell magic\n", 156 | "\n", 157 | "Вызов терминала с набором нескольких команд (не забываем сменить кодировку): " 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 10, 163 | "metadata": {}, 164 | "outputs": [ 165 | { 166 | "name": "stdout", 167 | "output_type": "stream", 168 | "text": [ 169 | "Microsoft Windows [Version 6.1.7601]\r\n", 170 | "Copyright (c) 2009 Microsoft Corporation. All rights reserved.\r\n", 171 | "\r\n", 172 | "(base) C:\\Users\\GLFS\\mathandpython\\week1>chcp 65001\n", 173 | "Active code page: 65001\r\n", 174 | "\r\n", 175 | "(base) C:\\Users\\GLFS\\mathandpython\\week1>cd ..\n", 176 | "\r\n", 177 | "(base) C:\\Users\\GLFS\\mathandpython>dir\n", 178 | " Volume in drive C has no label.\r\n", 179 | " Volume Serial Number is B009-5793\r\n", 180 | "\r\n", 181 | " Directory of C:\\Users\\GLFS\\mathandpython\r\n", 182 | "\r\n", 183 | "10.08.2019 00:34 .\r\n", 184 | "10.08.2019 00:34 ..\r\n", 185 | "10.08.2019 00:54 week1\r\n", 186 | " 0 File(s) 0 bytes\r\n", 187 | " 3 Dir(s) 447В 751В 618В 560 bytes free\r\n", 188 | "\r\n", 189 | "(base) C:\\Users\\GLFS\\mathandpython>" 190 | ] 191 | } 192 | ], 193 | "source": [ 194 | "%%cmd\n", 195 | "chcp 65001\n", 196 | "cd ..\n", 197 | "dir" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "## Список команд cell magic" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 11, 210 | "metadata": {}, 211 | "outputs": [ 212 | { 213 | "data": { 214 | "application/json": { 215 | "cell": { 216 | "!": "OSMagics", 217 | "HTML": "Other", 218 | "SVG": "Other", 219 | "bash": "Other", 220 | "capture": "ExecutionMagics", 221 | "cmd": "Other", 222 | "debug": "ExecutionMagics", 223 | "file": "Other", 224 | "html": "DisplayMagics", 225 | "javascript": "DisplayMagics", 226 | "js": "DisplayMagics", 227 | "latex": "DisplayMagics", 228 | "markdown": "DisplayMagics", 229 | "perl": "Other", 230 | "prun": "ExecutionMagics", 231 | "pypy": "Other", 232 | "python": "Other", 233 | "python2": "Other", 234 | "python3": "Other", 235 | "ruby": "Other", 236 | "script": "ScriptMagics", 237 | "sh": "Other", 238 | "svg": "DisplayMagics", 239 | "sx": "OSMagics", 240 | "system": "OSMagics", 241 | "time": "ExecutionMagics", 242 | "timeit": "ExecutionMagics", 243 | "writefile": "OSMagics" 244 | }, 245 | "line": { 246 | "alias": "OSMagics", 247 | "alias_magic": "BasicMagics", 248 | "autoawait": "AsyncMagics", 249 | "autocall": "AutoMagics", 250 | "automagic": "AutoMagics", 251 | "autosave": "KernelMagics", 252 | "bookmark": "OSMagics", 253 | "cd": "OSMagics", 254 | "clear": "KernelMagics", 255 | "cls": "KernelMagics", 256 | "colors": "BasicMagics", 257 | "conda": "PackagingMagics", 258 | "config": "ConfigMagics", 259 | "connect_info": "KernelMagics", 260 | "copy": "Other", 261 | "ddir": "Other", 262 | "debug": "ExecutionMagics", 263 | "dhist": "OSMagics", 264 | "dirs": "OSMagics", 265 | "doctest_mode": "BasicMagics", 266 | "echo": "Other", 267 | "ed": "Other", 268 | "edit": "KernelMagics", 269 | "env": "OSMagics", 270 | "gui": "BasicMagics", 271 | "hist": "Other", 272 | "history": "HistoryMagics", 273 | "killbgscripts": "ScriptMagics", 274 | "ldir": "Other", 275 | "less": "KernelMagics", 276 | "load": "CodeMagics", 277 | "load_ext": "ExtensionMagics", 278 | "loadpy": "CodeMagics", 279 | "logoff": "LoggingMagics", 280 | "logon": "LoggingMagics", 281 | "logstart": "LoggingMagics", 282 | "logstate": "LoggingMagics", 283 | "logstop": "LoggingMagics", 284 | "ls": "Other", 285 | "lsmagic": "BasicMagics", 286 | "macro": "ExecutionMagics", 287 | "magic": "BasicMagics", 288 | "matplotlib": "PylabMagics", 289 | "mkdir": "Other", 290 | "more": "KernelMagics", 291 | "notebook": "BasicMagics", 292 | "page": "BasicMagics", 293 | "pastebin": "CodeMagics", 294 | "pdb": "ExecutionMagics", 295 | "pdef": "NamespaceMagics", 296 | "pdoc": "NamespaceMagics", 297 | "pfile": "NamespaceMagics", 298 | "pinfo": "NamespaceMagics", 299 | "pinfo2": "NamespaceMagics", 300 | "pip": "PackagingMagics", 301 | "popd": "OSMagics", 302 | "pprint": "BasicMagics", 303 | "precision": "BasicMagics", 304 | "prun": "ExecutionMagics", 305 | "psearch": "NamespaceMagics", 306 | "psource": "NamespaceMagics", 307 | "pushd": "OSMagics", 308 | "pwd": "OSMagics", 309 | "pycat": "OSMagics", 310 | "pylab": "PylabMagics", 311 | "qtconsole": "KernelMagics", 312 | "quickref": "BasicMagics", 313 | "recall": "HistoryMagics", 314 | "rehashx": "OSMagics", 315 | "reload_ext": "ExtensionMagics", 316 | "ren": "Other", 317 | "rep": "Other", 318 | "rerun": "HistoryMagics", 319 | "reset": "NamespaceMagics", 320 | "reset_selective": "NamespaceMagics", 321 | "rmdir": "Other", 322 | "run": "ExecutionMagics", 323 | "save": "CodeMagics", 324 | "sc": "OSMagics", 325 | "set_env": "OSMagics", 326 | "store": "StoreMagics", 327 | "sx": "OSMagics", 328 | "system": "OSMagics", 329 | "tb": "ExecutionMagics", 330 | "time": "ExecutionMagics", 331 | "timeit": "ExecutionMagics", 332 | "unalias": "OSMagics", 333 | "unload_ext": "ExtensionMagics", 334 | "who": "NamespaceMagics", 335 | "who_ls": "NamespaceMagics", 336 | "whos": "NamespaceMagics", 337 | "xdel": "NamespaceMagics", 338 | "xmode": "BasicMagics" 339 | } 340 | }, 341 | "text/plain": [ 342 | "Available line magics:\n", 343 | "%alias %alias_magic %autoawait %autocall %automagic %autosave %bookmark %cd %clear %cls %colors %conda %config %connect_info %copy %ddir %debug %dhist %dirs %doctest_mode %echo %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %macro %magic %matplotlib %mkdir %more %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %pip %popd %pprint %precision %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %ren %rep %rerun %reset %reset_selective %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode\n", 344 | "\n", 345 | "Available cell magics:\n", 346 | "%%! %%HTML %%SVG %%bash %%capture %%cmd %%debug %%file %%html %%javascript %%js %%latex %%markdown %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefile\n", 347 | "\n", 348 | "Automagic is ON, % prefix IS NOT needed for line magics." 349 | ] 350 | }, 351 | "execution_count": 11, 352 | "metadata": {}, 353 | "output_type": "execute_result" 354 | } 355 | ], 356 | "source": [ 357 | "%lsmagic" 358 | ] 359 | }, 360 | { 361 | "cell_type": "markdown", 362 | "metadata": {}, 363 | "source": [ 364 | "## Работа с графикой pylab" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": 12, 370 | "metadata": {}, 371 | "outputs": [ 372 | { 373 | "name": "stdout", 374 | "output_type": "stream", 375 | "text": [ 376 | "Populating the interactive namespace from numpy and matplotlib\n" 377 | ] 378 | } 379 | ], 380 | "source": [ 381 | "%pylab inline" 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 13, 387 | "metadata": {}, 388 | "outputs": [ 389 | { 390 | "name": "stdout", 391 | "output_type": "stream", 392 | "text": [ 393 | "range(0, 11)\n" 394 | ] 395 | }, 396 | { 397 | "data": { 398 | "text/plain": [ 399 | "[]" 400 | ] 401 | }, 402 | "execution_count": 13, 403 | "metadata": {}, 404 | "output_type": "execute_result" 405 | }, 406 | { 407 | "data": { 408 | "image/png": "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\n", 409 | "text/plain": [ 410 | "
" 411 | ] 412 | }, 413 | "metadata": { 414 | "needs_background": "light" 415 | }, 416 | "output_type": "display_data" 417 | } 418 | ], 419 | "source": [ 420 | "y = range(11)\n", 421 | "print(y)\n", 422 | "plot(y)" 423 | ] 424 | }, 425 | { 426 | "cell_type": "code", 427 | "execution_count": 14, 428 | "metadata": {}, 429 | "outputs": [ 430 | { 431 | "data": { 432 | "text/plain": [ 433 | "'1.16.4'" 434 | ] 435 | }, 436 | "execution_count": 14, 437 | "metadata": {}, 438 | "output_type": "execute_result" 439 | } 440 | ], 441 | "source": [ 442 | "import numpy\n", 443 | "numpy.__version__" 444 | ] 445 | }, 446 | { 447 | "cell_type": "code", 448 | "execution_count": 15, 449 | "metadata": {}, 450 | "outputs": [ 451 | { 452 | "data": { 453 | "text/plain": [ 454 | "'1.2.1'" 455 | ] 456 | }, 457 | "execution_count": 15, 458 | "metadata": {}, 459 | "output_type": "execute_result" 460 | } 461 | ], 462 | "source": [ 463 | "import scipy\n", 464 | "scipy.__version__" 465 | ] 466 | }, 467 | { 468 | "cell_type": "code", 469 | "execution_count": 16, 470 | "metadata": {}, 471 | "outputs": [ 472 | { 473 | "data": { 474 | "text/plain": [ 475 | "'0.24.2'" 476 | ] 477 | }, 478 | "execution_count": 16, 479 | "metadata": {}, 480 | "output_type": "execute_result" 481 | } 482 | ], 483 | "source": [ 484 | "import pandas\n", 485 | "pandas.__version__" 486 | ] 487 | }, 488 | { 489 | "cell_type": "code", 490 | "execution_count": 17, 491 | "metadata": {}, 492 | "outputs": [ 493 | { 494 | "data": { 495 | "text/plain": [ 496 | "'3.1.0'" 497 | ] 498 | }, 499 | "execution_count": 17, 500 | "metadata": {}, 501 | "output_type": "execute_result" 502 | } 503 | ], 504 | "source": [ 505 | "import matplotlib\n", 506 | "matplotlib.__version__" 507 | ] 508 | }, 509 | { 510 | "cell_type": "code", 511 | "execution_count": null, 512 | "metadata": {}, 513 | "outputs": [], 514 | "source": [] 515 | } 516 | ], 517 | "metadata": { 518 | "kernelspec": { 519 | "display_name": "Python 3", 520 | "language": "python", 521 | "name": "python3" 522 | }, 523 | "language_info": { 524 | "codemirror_mode": { 525 | "name": "ipython", 526 | "version": 3 527 | }, 528 | "file_extension": ".py", 529 | "mimetype": "text/x-python", 530 | "name": "python", 531 | "nbconvert_exporter": "python", 532 | "pygments_lexer": "ipython3", 533 | "version": "3.7.3" 534 | } 535 | }, 536 | "nbformat": 4, 537 | "nbformat_minor": 2 538 | } 539 | -------------------------------------------------------------------------------- /week1/3.4. Reading from files (Python 3).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 4, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "?open" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 9, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "ename": "NameError", 19 | "evalue": "name '_io' is not defined", 20 | "output_type": "error", 21 | "traceback": [ 22 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 23 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 24 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0m_io\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTextIOWrapper\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__doc__\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 25 | "\u001b[1;31mNameError\u001b[0m: name '_io' is not defined" 26 | ] 27 | } 28 | ], 29 | "source": [ 30 | "_io.TextIOWrapper.__doc__" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "?sorted" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 12, 45 | "metadata": {}, 46 | "outputs": [ 47 | { 48 | "name": "stdout", 49 | "output_type": "stream", 50 | "text": [ 51 | "Привет, мир!\n", 52 | "тестовый файл\n", 53 | "урок \"чтение данных в python\"\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "file_obj = open('example_utf8.txt', 'r', encoding = 'utf-8')\n", 59 | "type(file_obj)\n", 60 | "print(file_obj.read())" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 14, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "name": "stdout", 70 | "output_type": "stream", 71 | "text": [ 72 | "Привет, мир!\n", 73 | "\n" 74 | ] 75 | } 76 | ], 77 | "source": [ 78 | "file_obj = open('example_utf8.txt', 'r', encoding = 'utf-8')\n", 79 | "print (file_obj.readline())" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": 16, 85 | "metadata": {}, 86 | "outputs": [ 87 | { 88 | "name": "stdout", 89 | "output_type": "stream", 90 | "text": [ 91 | "Привет, мир!\n", 92 | "тестовый файл\n", 93 | "урок \"чтение данных в python\"\n" 94 | ] 95 | } 96 | ], 97 | "source": [ 98 | "file_obj = open('example_utf8.txt', 'r', encoding = 'utf-8')\n", 99 | "data_list = list(file_obj)\n", 100 | "for line in data_list:\n", 101 | " print (line.strip())" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 17, 107 | "metadata": {}, 108 | "outputs": [ 109 | { 110 | "name": "stdout", 111 | "output_type": "stream", 112 | "text": [ 113 | "Привет, мир!\n", 114 | "тестовый файл\n", 115 | "урок \"чтение данных в python\"\n" 116 | ] 117 | } 118 | ], 119 | "source": [ 120 | "file_obj = open('example_utf8.txt', 'r', encoding = 'utf-8')\n", 121 | "data_list = file_obj.readlines()\n", 122 | "for line in data_list: print (line.strip())" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 18, 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "ename": "ValueError", 132 | "evalue": "I/O operation on closed file.", 133 | "output_type": "error", 134 | "traceback": [ 135 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 136 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 137 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mfile_obj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'example_utf8.txt'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mfile_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mfile_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 138 | "\u001b[1;31mValueError\u001b[0m: I/O operation on closed file." 139 | ] 140 | } 141 | ], 142 | "source": [ 143 | "#попытка чтения закрытого файла приводит к ошибке!\n", 144 | "file_obj = open('example_utf8.txt')\n", 145 | "file_obj.close()\n", 146 | "file_obj.read()" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 19, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "name": "stdout", 156 | "output_type": "stream", 157 | "text": [ 158 | "рТЙЧЕФ, НЙТ!\n", 159 | "ьФП ФЕУФПЧЩК ЖБКМ\n", 160 | "лПДЙТПЧЛБ koi8-r\n", 161 | "хТПЛ \"ЮФЕОЙЕ ДБООЩИ Ч python\"\n" 162 | ] 163 | } 164 | ], 165 | "source": [ 166 | "file_obj = open('example_koi_8.txt')\n", 167 | "print(file_obj.read())" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 24, 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "name": "stdout", 177 | "output_type": "stream", 178 | "text": [ 179 | "Привет, мир!\n", 180 | "Это тестовый файл\n", 181 | "Кодировка koi8-r\n", 182 | "Урок \"чтение данных в python\"\n" 183 | ] 184 | } 185 | ], 186 | "source": [ 187 | "file_obj = open('example_koi_8.txt', encoding='koi8-r')\n", 188 | "print(file_obj.read())" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 23, 194 | "metadata": {}, 195 | "outputs": [], 196 | "source": [] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [] 204 | } 205 | ], 206 | "metadata": { 207 | "kernelspec": { 208 | "display_name": "Python 3", 209 | "language": "python", 210 | "name": "python3" 211 | }, 212 | "language_info": { 213 | "codemirror_mode": { 214 | "name": "ipython", 215 | "version": 3 216 | }, 217 | "file_extension": ".py", 218 | "mimetype": "text/x-python", 219 | "name": "python", 220 | "nbconvert_exporter": "python", 221 | "pygments_lexer": "ipython3", 222 | "version": "3.7.3" 223 | } 224 | }, 225 | "nbformat": 4, 226 | "nbformat_minor": 2 227 | } 228 | -------------------------------------------------------------------------------- /week1/Untitled.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /week1/Writing to files (Python 2).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Запись в файл " 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 41, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "file_obj = open('file_to_write_in.txt', 'w')\n", 17 | "string = 'строка для записи в файл\\n'\n", 18 | "file_obj.write(string)\n", 19 | "file_obj.close()" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 28, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "name": "stderr", 29 | "output_type": "stream", 30 | "text": [ 31 | "'cat' is not recognized as an internal or external command,\n", 32 | "operable program or batch file.\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "!cat file_to_write_in.txt" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 42, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "Microsoft Windows [Version 6.1.7601]\r\n", 50 | "Copyright (c) 2009 Microsoft Corporation. All rights reserved.\r\n", 51 | "\r\n", 52 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>chcp 65001\n", 53 | "Active code page: 65001\r\n", 54 | "\r\n", 55 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>type file_to_write_in.txt\n", 56 | "строка для записи в файл\r\n", 57 | "\r\n", 58 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "%%cmd\n", 64 | "chcp 65001\n", 65 | "type file_to_write_in.txt\n" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "\n" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 43, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "#запись строки в файл, открытый в режиме 'w'\n", 84 | "file_obj = open('file_to_write_in.txt', 'w')\n", 85 | "second_string = 'вторая строка для записи в файл\\n'\n", 86 | "file_obj.write(second_string)\n", 87 | "file_obj.close()" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 44, 93 | "metadata": {}, 94 | "outputs": [ 95 | { 96 | "name": "stdout", 97 | "output_type": "stream", 98 | "text": [ 99 | "Microsoft Windows [Version 6.1.7601]\r\n", 100 | "Copyright (c) 2009 Microsoft Corporation. All rights reserved.\r\n", 101 | "\r\n", 102 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>chcp 65001\n", 103 | "Active code page: 65001\r\n", 104 | "\r\n", 105 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>type file_to_write_in.txt\n", 106 | "вторая строка для записи в файл\r\n", 107 | "\r\n", 108 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "%%cmd\n", 114 | "chcp 65001\n", 115 | "type file_to_write_in.txt" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "## В режиме 'w' файл перезаписался! Используем режим append 'a'" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 45, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [ 131 | "#запись строки в файл, открытый в режиме 'a'\n", 132 | "file_obj = open('file_to_write_in.txt', 'a')\n", 133 | "second_string = 'третья строка для записи в файл\\n'\n", 134 | "file_obj.write(second_string)\n", 135 | "file_obj.close()" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 46, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "Microsoft Windows [Version 6.1.7601]\r\n", 148 | "Copyright (c) 2009 Microsoft Corporation. All rights reserved.\r\n", 149 | "\r\n", 150 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>chcp 65001\n", 151 | "Active code page: 65001\r\n", 152 | "\r\n", 153 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>type file_to_write_in.txt\n", 154 | "вторая строка для записи в файл\r\n", 155 | "третья строка для записи в файл\r\n", 156 | "\r\n", 157 | "(py27) C:\\Users\\GLFS\\mathandpython\\week1>" 158 | ] 159 | } 160 | ], 161 | "source": [ 162 | "%%cmd\n", 163 | "chcp 65001\n", 164 | "type file_to_write_in.txt" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": 47, 170 | "metadata": {}, 171 | "outputs": [], 172 | "source": [ 173 | "#создание списка чисел от 1 до 10\n", 174 | "digits = range(1,11)" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 48, 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "data": { 184 | "text/plain": [ 185 | "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" 186 | ] 187 | }, 188 | "execution_count": 48, 189 | "metadata": {}, 190 | "output_type": "execute_result" 191 | } 192 | ], 193 | "source": [ 194 | "digits" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": 49, 200 | "metadata": {}, 201 | "outputs": [], 202 | "source": [ 203 | "with open('second_file_for_write_in.txt', 'w') as file_obj:\n", 204 | " file_obj.writelines(digit + '\\n' for digit in map(str, digits))" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 50, 210 | "metadata": {}, 211 | "outputs": [ 212 | { 213 | "name": "stdout", 214 | "output_type": "stream", 215 | "text": [ 216 | "1\n", 217 | "2\n", 218 | "3\n", 219 | "4\n", 220 | "5\n", 221 | "6\n", 222 | "7\n", 223 | "8\n", 224 | "9\n", 225 | "10\n", 226 | "\n" 227 | ] 228 | } 229 | ], 230 | "source": [ 231 | "#вывод на экран содержимого файла\n", 232 | "with open('second_file_for_write_in.txt', 'r') as file_obj:\n", 233 | " print file_obj.read()" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 51, 239 | "metadata": {}, 240 | "outputs": [ 241 | { 242 | "name": "stdout", 243 | "output_type": "stream", 244 | "text": [ 245 | "['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']\n" 246 | ] 247 | } 248 | ], 249 | "source": [ 250 | "print map(str, digits)" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 54, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "name": "stdout", 260 | "output_type": "stream", 261 | "text": [ 262 | "['1\\n', '2\\n', '3\\n', '4\\n', '5\\n', '6\\n', '7\\n', '8\\n', '9\\n', '10\\n']\n" 263 | ] 264 | } 265 | ], 266 | "source": [ 267 | "print list((digit + '\\n' for digit in map(str, digits)))" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 55, 273 | "metadata": {}, 274 | "outputs": [ 275 | { 276 | "data": { 277 | "text/plain": [ 278 | "{1: '1', 2: 2}" 279 | ] 280 | }, 281 | "execution_count": 55, 282 | "metadata": {}, 283 | "output_type": "execute_result" 284 | } 285 | ], 286 | "source": [ 287 | "d = dict()\n", 288 | "d[1] = '1'\n", 289 | "d[2] = 2\n", 290 | "d" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": null, 296 | "metadata": {}, 297 | "outputs": [], 298 | "source": [] 299 | } 300 | ], 301 | "metadata": { 302 | "kernelspec": { 303 | "display_name": "Python 2", 304 | "language": "python", 305 | "name": "python2" 306 | }, 307 | "language_info": { 308 | "codemirror_mode": { 309 | "name": "ipython", 310 | "version": 2 311 | }, 312 | "file_extension": ".py", 313 | "mimetype": "text/x-python", 314 | "name": "python", 315 | "nbconvert_exporter": "python", 316 | "pygments_lexer": "ipython2", 317 | "version": "2.7.16" 318 | } 319 | }, 320 | "nbformat": 4, 321 | "nbformat_minor": 2 322 | } 323 | -------------------------------------------------------------------------------- /week1/example_koi_8.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/week1/example_koi_8.txt -------------------------------------------------------------------------------- /week1/example_utf8.txt: -------------------------------------------------------------------------------- 1 | Привет, мир! 2 | тестовый файл 3 | урок "чтение данных в python" -------------------------------------------------------------------------------- /week1/file_to_write_in.txt: -------------------------------------------------------------------------------- 1 | вторая строка для записи в файл 2 | третья строка для записи в файл 3 | -------------------------------------------------------------------------------- /week1/from authors/example_koi_8.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/week1/from authors/example_koi_8.txt -------------------------------------------------------------------------------- /week1/from authors/example_utf8.txt: -------------------------------------------------------------------------------- 1 | Привет, мир! 2 | тестовый файл 3 | урок "чтение данных в python" -------------------------------------------------------------------------------- /week1/from authors/introduction_to_ipython.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "data": { 10 | "text/plain": [ 11 | "'hello, world!'" 12 | ] 13 | }, 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "output_type": "execute_result" 17 | } 18 | ], 19 | "source": [ 20 | "'hello, world!'" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": { 27 | "collapsed": true 28 | }, 29 | "outputs": [], 30 | "source": [ 31 | "t = 'hello, world!'" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 3, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "data": { 41 | "text/plain": [ 42 | "'hello, world!'" 43 | ] 44 | }, 45 | "execution_count": 3, 46 | "metadata": {}, 47 | "output_type": "execute_result" 48 | } 49 | ], 50 | "source": [ 51 | "t" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 4, 57 | "metadata": {}, 58 | "outputs": [ 59 | { 60 | "name": "stdout", 61 | "output_type": "stream", 62 | "text": [ 63 | "hello, world!\n" 64 | ] 65 | } 66 | ], 67 | "source": [ 68 | "print t" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 5, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "1296" 80 | ] 81 | }, 82 | "execution_count": 5, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "6**4" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 6, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "data": { 98 | "text/plain": [ 99 | "8" 100 | ] 101 | }, 102 | "execution_count": 6, 103 | "metadata": {}, 104 | "output_type": "execute_result" 105 | } 106 | ], 107 | "source": [ 108 | "100/12" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 7, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "data": { 118 | "text/plain": [ 119 | "8.333333333333334" 120 | ] 121 | }, 122 | "execution_count": 7, 123 | "metadata": {}, 124 | "output_type": "execute_result" 125 | } 126 | ], 127 | "source": [ 128 | "100./12" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 8, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "data": { 138 | "text/plain": [ 139 | "8.333" 140 | ] 141 | }, 142 | "execution_count": 8, 143 | "metadata": {}, 144 | "output_type": "execute_result" 145 | } 146 | ], 147 | "source": [ 148 | "round(100./12, 3)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 9, 154 | "metadata": { 155 | "collapsed": true 156 | }, 157 | "outputs": [], 158 | "source": [ 159 | "from math import factorial" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 10, 165 | "metadata": {}, 166 | "outputs": [ 167 | { 168 | "data": { 169 | "text/plain": [ 170 | "6" 171 | ] 172 | }, 173 | "execution_count": 10, 174 | "metadata": {}, 175 | "output_type": "execute_result" 176 | } 177 | ], 178 | "source": [ 179 | "factorial(3)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 11, 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "data": { 189 | "text/plain": [ 190 | "1814400.0" 191 | ] 192 | }, 193 | "execution_count": 11, 194 | "metadata": {}, 195 | "output_type": "execute_result" 196 | } 197 | ], 198 | "source": [ 199 | "factorial(10)*0.5" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "text" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "# Header" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "для редактирования формулы ниже использует синтаксис tex" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "$$ c = \\sqrt{a^2 + b^2}$$" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 38, 233 | "metadata": {}, 234 | "outputs": [ 235 | { 236 | "name": "stdout", 237 | "output_type": "stream", 238 | "text": [ 239 | "hello, world!\r\n" 240 | ] 241 | } 242 | ], 243 | "source": [ 244 | "! echo 'hello, world!'" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": 39, 250 | "metadata": {}, 251 | "outputs": [ 252 | { 253 | "name": "stdout", 254 | "output_type": "stream", 255 | "text": [ 256 | "hello, world!\r\n" 257 | ] 258 | } 259 | ], 260 | "source": [ 261 | "!echo $t" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 37, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "name": "stdout", 271 | "output_type": "stream", 272 | "text": [ 273 | ".\n", 274 | "..\n" 275 | ] 276 | } 277 | ], 278 | "source": [ 279 | "%%bash\n", 280 | "mkdir test_directory\n", 281 | "cd test_directory/\n", 282 | "ls -a" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 42, 288 | "metadata": {}, 289 | "outputs": [], 290 | "source": [ 291 | "#удаление директории, если она не нужна\n", 292 | "! rm -r test_directory" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": {}, 298 | "source": [ 299 | "Ниже аналоги команд для пользователей Windows:" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": {}, 306 | "outputs": [], 307 | "source": [ 308 | "%%cmd\n", 309 | "mkdir test_directory\n", 310 | "cd test_directory\n", 311 | "dir" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "удаление директории, если она не нужна (windows)" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "%%cmd \n", 328 | "rmdir test_directiory" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 23, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "data": { 338 | "application/json": { 339 | "cell": { 340 | "!": "OSMagics", 341 | "HTML": "Other", 342 | "SVG": "Other", 343 | "bash": "Other", 344 | "capture": "ExecutionMagics", 345 | "debug": "ExecutionMagics", 346 | "file": "Other", 347 | "html": "DisplayMagics", 348 | "javascript": "DisplayMagics", 349 | "latex": "DisplayMagics", 350 | "perl": "Other", 351 | "prun": "ExecutionMagics", 352 | "pypy": "Other", 353 | "python": "Other", 354 | "python2": "Other", 355 | "python3": "Other", 356 | "ruby": "Other", 357 | "script": "ScriptMagics", 358 | "sh": "Other", 359 | "svg": "DisplayMagics", 360 | "sx": "OSMagics", 361 | "system": "OSMagics", 362 | "time": "ExecutionMagics", 363 | "timeit": "ExecutionMagics", 364 | "writefile": "OSMagics" 365 | }, 366 | "line": { 367 | "alias": "OSMagics", 368 | "alias_magic": "BasicMagics", 369 | "autocall": "AutoMagics", 370 | "automagic": "AutoMagics", 371 | "autosave": "KernelMagics", 372 | "bookmark": "OSMagics", 373 | "cat": "Other", 374 | "cd": "OSMagics", 375 | "clear": "KernelMagics", 376 | "colors": "BasicMagics", 377 | "config": "ConfigMagics", 378 | "connect_info": "KernelMagics", 379 | "cp": "Other", 380 | "debug": "ExecutionMagics", 381 | "dhist": "OSMagics", 382 | "dirs": "OSMagics", 383 | "doctest_mode": "BasicMagics", 384 | "ed": "Other", 385 | "edit": "KernelMagics", 386 | "env": "OSMagics", 387 | "gui": "BasicMagics", 388 | "hist": "Other", 389 | "history": "HistoryMagics", 390 | "install_default_config": "DeprecatedMagics", 391 | "install_ext": "ExtensionMagics", 392 | "install_profiles": "DeprecatedMagics", 393 | "killbgscripts": "ScriptMagics", 394 | "ldir": "Other", 395 | "less": "KernelMagics", 396 | "lf": "Other", 397 | "lk": "Other", 398 | "ll": "Other", 399 | "load": "CodeMagics", 400 | "load_ext": "ExtensionMagics", 401 | "loadpy": "CodeMagics", 402 | "logoff": "LoggingMagics", 403 | "logon": "LoggingMagics", 404 | "logstart": "LoggingMagics", 405 | "logstate": "LoggingMagics", 406 | "logstop": "LoggingMagics", 407 | "ls": "Other", 408 | "lsmagic": "BasicMagics", 409 | "lx": "Other", 410 | "macro": "ExecutionMagics", 411 | "magic": "BasicMagics", 412 | "man": "KernelMagics", 413 | "matplotlib": "PylabMagics", 414 | "mkdir": "Other", 415 | "more": "KernelMagics", 416 | "mv": "Other", 417 | "notebook": "BasicMagics", 418 | "page": "BasicMagics", 419 | "pastebin": "CodeMagics", 420 | "pdb": "ExecutionMagics", 421 | "pdef": "NamespaceMagics", 422 | "pdoc": "NamespaceMagics", 423 | "pfile": "NamespaceMagics", 424 | "pinfo": "NamespaceMagics", 425 | "pinfo2": "NamespaceMagics", 426 | "popd": "OSMagics", 427 | "pprint": "BasicMagics", 428 | "precision": "BasicMagics", 429 | "profile": "BasicMagics", 430 | "prun": "ExecutionMagics", 431 | "psearch": "NamespaceMagics", 432 | "psource": "NamespaceMagics", 433 | "pushd": "OSMagics", 434 | "pwd": "OSMagics", 435 | "pycat": "OSMagics", 436 | "pylab": "PylabMagics", 437 | "qtconsole": "KernelMagics", 438 | "quickref": "BasicMagics", 439 | "recall": "HistoryMagics", 440 | "rehashx": "OSMagics", 441 | "reload_ext": "ExtensionMagics", 442 | "rep": "Other", 443 | "rerun": "HistoryMagics", 444 | "reset": "NamespaceMagics", 445 | "reset_selective": "NamespaceMagics", 446 | "rm": "Other", 447 | "rmdir": "Other", 448 | "run": "ExecutionMagics", 449 | "save": "CodeMagics", 450 | "sc": "OSMagics", 451 | "set_env": "OSMagics", 452 | "store": "StoreMagics", 453 | "sx": "OSMagics", 454 | "system": "OSMagics", 455 | "tb": "ExecutionMagics", 456 | "time": "ExecutionMagics", 457 | "timeit": "ExecutionMagics", 458 | "unalias": "OSMagics", 459 | "unload_ext": "ExtensionMagics", 460 | "who": "NamespaceMagics", 461 | "who_ls": "NamespaceMagics", 462 | "whos": "NamespaceMagics", 463 | "xdel": "NamespaceMagics", 464 | "xmode": "BasicMagics", 465 | "ydf": "YdfLoaderMagics" 466 | } 467 | }, 468 | "text/plain": [ 469 | "Available line magics:\n", 470 | "%alias %alias_magic %autocall %automagic %autosave %bookmark %cat %cd %clear %colors %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %hist %history %install_default_config %install_ext %install_profiles %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %mv %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode %ydf\n", 471 | "\n", 472 | "Available cell magics:\n", 473 | "%%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%latex %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefile\n", 474 | "\n", 475 | "Automagic is ON, % prefix IS NOT needed for line magics." 476 | ] 477 | }, 478 | "execution_count": 23, 479 | "metadata": {}, 480 | "output_type": "execute_result" 481 | } 482 | ], 483 | "source": [ 484 | "%lsmagic" 485 | ] 486 | }, 487 | { 488 | "cell_type": "code", 489 | "execution_count": 24, 490 | "metadata": {}, 491 | "outputs": [ 492 | { 493 | "name": "stdout", 494 | "output_type": "stream", 495 | "text": [ 496 | "Populating the interactive namespace from numpy and matplotlib\n" 497 | ] 498 | } 499 | ], 500 | "source": [ 501 | "%pylab inline" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": 25, 507 | "metadata": { 508 | "collapsed": true 509 | }, 510 | "outputs": [], 511 | "source": [ 512 | "y = range(11)" 513 | ] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": 26, 518 | "metadata": {}, 519 | "outputs": [ 520 | { 521 | "data": { 522 | "text/plain": [ 523 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" 524 | ] 525 | }, 526 | "execution_count": 26, 527 | "metadata": {}, 528 | "output_type": "execute_result" 529 | } 530 | ], 531 | "source": [ 532 | "y" 533 | ] 534 | }, 535 | { 536 | "cell_type": "code", 537 | "execution_count": 40, 538 | "metadata": {}, 539 | "outputs": [ 540 | { 541 | "data": { 542 | "text/plain": [ 543 | "[]" 544 | ] 545 | }, 546 | "execution_count": 40, 547 | "metadata": {}, 548 | "output_type": "execute_result" 549 | }, 550 | { 551 | "data": { 552 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 553 | "text/plain": [ 554 | "" 555 | ] 556 | }, 557 | "metadata": {}, 558 | "output_type": "display_data" 559 | } 560 | ], 561 | "source": [ 562 | "plot(y)" 563 | ] 564 | } 565 | ], 566 | "metadata": { 567 | "kernelspec": { 568 | "display_name": "Python 3", 569 | "language": "python", 570 | "name": "python3" 571 | }, 572 | "language_info": { 573 | "codemirror_mode": { 574 | "name": "ipython", 575 | "version": 3 576 | }, 577 | "file_extension": ".py", 578 | "mimetype": "text/x-python", 579 | "name": "python", 580 | "nbconvert_exporter": "python", 581 | "pygments_lexer": "ipython3", 582 | "version": "3.7.3" 583 | } 584 | }, 585 | "nbformat": 4, 586 | "nbformat_minor": 1 587 | } 588 | -------------------------------------------------------------------------------- /week1/from authors/ipython_files_data_reading.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Чтение данных из файла" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": null, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "?open" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "#открытие файла для чтения с помощью встроенной функции open\n", 30 | "file_obj = open('example_utf8.txt', 'r')" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "type(file_obj)" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "print file_obj.read()" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "file_obj = open('example_utf8.txt')\n", 58 | "print file_obj.readline()" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "print file_obj.readline()" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": { 74 | "collapsed": true 75 | }, 76 | "outputs": [], 77 | "source": [ 78 | "file_obj = open('example_utf8.txt')" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "for line in file_obj:\n", 88 | " print line.strip()" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": { 95 | "collapsed": true 96 | }, 97 | "outputs": [], 98 | "source": [ 99 | "file_obj = open('example_utf8.txt')\n", 100 | "data_list = list(file_obj)" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": null, 106 | "metadata": {}, 107 | "outputs": [], 108 | "source": [ 109 | "for line in data_list: print line.strip()" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "collapsed": true 117 | }, 118 | "outputs": [], 119 | "source": [ 120 | "file_obj = open('example_utf8.txt')\n", 121 | "data_list = file_obj.readlines()" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "for line in data_list: print line.strip()" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "#попытка чтения закрытого файла приводит к ошибке!\n", 140 | "file_obj = open('example_utf8.txt')\n", 141 | "file_obj.close()\n", 142 | "file_obj.read()" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": null, 148 | "metadata": { 149 | "collapsed": true 150 | }, 151 | "outputs": [], 152 | "source": [ 153 | "file_obj = open('example_koi_8.txt')" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [ 162 | "#вывод на экран файла в кодировке koi8-r\n", 163 | "print file_obj.read()" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "# Codecs" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": { 177 | "collapsed": true 178 | }, 179 | "outputs": [], 180 | "source": [ 181 | "import codecs" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": { 188 | "collapsed": true 189 | }, 190 | "outputs": [], 191 | "source": [ 192 | "#открытие файла для чтения с помощью функции open модуля codecs с указанием кодировки koi8-r\n", 193 | "file_obj = codecs.open('example_koi_8.txt', 'r', encoding='koi8-r')" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [ 202 | "print file_obj.read()" 203 | ] 204 | } 205 | ], 206 | "metadata": { 207 | "kernelspec": { 208 | "display_name": "Python 2", 209 | "language": "python", 210 | "name": "python2" 211 | }, 212 | "language_info": { 213 | "codemirror_mode": { 214 | "name": "ipython", 215 | "version": 2 216 | }, 217 | "file_extension": ".py", 218 | "mimetype": "text/x-python", 219 | "name": "python", 220 | "nbconvert_exporter": "python", 221 | "pygments_lexer": "ipython2", 222 | "version": "2.7.16" 223 | } 224 | }, 225 | "nbformat": 4, 226 | "nbformat_minor": 1 227 | } 228 | -------------------------------------------------------------------------------- /week1/from authors/ipython_files_data_writing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Запись в файл " 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": null, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "#запись строки в файл, открытый в режиме 'w'\n", 19 | "file_obj = open('file_to_write_in.txt', 'w')\n", 20 | "string = 'строка для записи в файл\\n'\n", 21 | "file_obj.write(string)\n", 22 | "file_obj.close()" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "!cat file_to_write_in.txt" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "#аналог предыдущей команды для пользователей windows\n", 41 | "!more file_to_write_in.txt" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": { 48 | "collapsed": true 49 | }, 50 | "outputs": [], 51 | "source": [ 52 | "#запись строки в файл, открытый в режиме 'w'\n", 53 | "file_obj = open('file_to_write_in.txt', 'w')\n", 54 | "second_string = 'вторая строка для записи в файл\\n'\n", 55 | "file_obj.write(second_string)\n", 56 | "file_obj.close()" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "!cat file_to_write_in.txt" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "#аналог для пользователей windows\n", 75 | "!more file_to_write_in.txt" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": { 82 | "collapsed": true 83 | }, 84 | "outputs": [], 85 | "source": [ 86 | "#запись строки в файл, открытый в режиме 'a'\n", 87 | "file_obj = open('file_to_write_in.txt', 'a')\n", 88 | "second_string = 'третья строка для записи в файл\\n'\n", 89 | "file_obj.write(second_string)\n", 90 | "file_obj.close()" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": { 97 | "collapsed": true 98 | }, 99 | "outputs": [], 100 | "source": [ 101 | "#создание списка чисел от 1 до 10\n", 102 | "digits = range(1,11)" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "digits" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": { 118 | "collapsed": true 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "#запись в файл списка строк с помощью функции writelines\n", 123 | "file_obj = open('second_file_for_write_in.txt', 'w')\n", 124 | "file_obj.writelines(digit + '\\n' for digit in map(str, digits))\n", 125 | "file_obj.close()" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "#вывод на экран содержимого файла\n", 135 | "with open('second_file_for_write_in.txt', 'r') as file_obj:\n", 136 | " print file_obj.read()" 137 | ] 138 | } 139 | ], 140 | "metadata": { 141 | "kernelspec": { 142 | "display_name": "Python 2", 143 | "language": "python", 144 | "name": "python2" 145 | }, 146 | "language_info": { 147 | "codemirror_mode": { 148 | "name": "ipython", 149 | "version": 2 150 | }, 151 | "file_extension": ".py", 152 | "mimetype": "text/x-python", 153 | "name": "python", 154 | "nbconvert_exporter": "python", 155 | "pygments_lexer": "ipython2", 156 | "version": "2.7.16" 157 | } 158 | }, 159 | "nbformat": 4, 160 | "nbformat_minor": 1 161 | } 162 | -------------------------------------------------------------------------------- /week1/second_file_for_write_in.txt: -------------------------------------------------------------------------------- 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 10 | 10 11 | -------------------------------------------------------------------------------- /week2/SciPy_Optimization (Python 2).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "from scipy import optimize" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 3, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stdout", 19 | "output_type": "stream", 20 | "text": [ 21 | "0.0\n" 22 | ] 23 | } 24 | ], 25 | "source": [ 26 | "def f(x):\n", 27 | " return 0.5* (1 - x[0]) ** 2 + (x[1] - x[0] ** 2) ** 2\n", 28 | "print f([1, 1])" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 7, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "name": "stdout", 38 | "output_type": "stream", 39 | "text": [ 40 | "[0.99999324 1.00001283]\n" 41 | ] 42 | } 43 | ], 44 | "source": [ 45 | "result = optimize.brute(f, ((-5, 5), (-5, 5)))\n", 46 | "print result" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 18, 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "name": "stdout", 56 | "output_type": "stream", 57 | "text": [ 58 | "[1.00000047 0.99999021]\n" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "result = optimize.brute(f, ((1000, 1001), (1000, 1001)))\n", 64 | "print result" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 15, 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "text/plain": [ 75 | "9998000149990000.0" 76 | ] 77 | }, 78 | "execution_count": 15, 79 | "metadata": {}, 80 | "output_type": "execute_result" 81 | } 82 | ], 83 | "source": [ 84 | "f([10000, 10000])" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 32, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "(slice(100, 101, 0.01), slice(100, 101, 0.01))\n" 97 | ] 98 | } 99 | ], 100 | "source": [ 101 | "rranges = (slice(100, 101, 0.01), slice(100, 101, 0.01))\n", 102 | "print rranges" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 33, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "[100. 100.99]\n" 115 | ] 116 | } 117 | ], 118 | "source": [ 119 | "result = optimize.brute(f, rranges, finish=None)\n", 120 | "print result" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 30, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "name": "stdout", 130 | "output_type": "stream", 131 | "text": [ 132 | " fun: 7.395570986446986e-32\n", 133 | " message: 'Optimization terminated successfully.'\n", 134 | " nfev: 3663L\n", 135 | " nit: 121\n", 136 | " success: True\n", 137 | " x: array([1., 1.])\n" 138 | ] 139 | } 140 | ], 141 | "source": [ 142 | "result = optimize.differential_evolution(f, ((-5, 5), (-5, 5)))\n", 143 | "print result" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 34, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "import numpy as np \n", 153 | "\n", 154 | "def g(x): ## используем градиент\n", 155 | " return np.array((-2*.5*(1 - x[0]) - 4*x[0]*(x[1] - x[0]**2), 2*(x[1] - x[0]**2)))" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 38, 161 | "metadata": {}, 162 | "outputs": [ 163 | { 164 | "name": "stdout", 165 | "output_type": "stream", 166 | "text": [ 167 | "2.384185791015625e-07\n" 168 | ] 169 | } 170 | ], 171 | "source": [ 172 | "print optimize.check_grad(f, g, [2, 2])" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 39, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "?optimize.check_grad" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 40, 187 | "metadata": {}, 188 | "outputs": [ 189 | { 190 | "name": "stdout", 191 | "output_type": "stream", 192 | "text": [ 193 | "Optimization terminated successfully.\n", 194 | " Current function value: 0.000000\n", 195 | " Iterations: 8\n", 196 | " Function evaluations: 9\n", 197 | " Gradient evaluations: 9\n", 198 | "[1.00000582 1.00001285]\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "print optimize.fmin_bfgs(f, [2, 2], fprime=g)" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 41, 209 | "metadata": {}, 210 | "outputs": [ 211 | { 212 | "name": "stdout", 213 | "output_type": "stream", 214 | "text": [ 215 | " fun: 1.7837922314048395e-11\n", 216 | " hess_inv: array([[0.95489065, 1.90006641],\n", 217 | " [1.90006641, 4.27872401]])\n", 218 | " jac: array([9.88094926e-07, 2.41748031e-06])\n", 219 | " message: 'Optimization terminated successfully.'\n", 220 | " nfev: 36\n", 221 | " nit: 8\n", 222 | " njev: 9\n", 223 | " status: 0\n", 224 | " success: True\n", 225 | " x: array([1.00000573, 1.00001265])\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "print optimize.minimize(f, [2,2])" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 45, 236 | "metadata": {}, 237 | "outputs": [ 238 | { 239 | "name": "stdout", 240 | "output_type": "stream", 241 | "text": [ 242 | " fun: 1.7837922314048395e-11\n", 243 | " hess_inv: array([[0.95489065, 1.90006641],\n", 244 | " [1.90006641, 4.27872401]])\n", 245 | " jac: array([9.88094926e-07, 2.41748031e-06])\n", 246 | " message: 'Optimization terminated successfully.'\n", 247 | " nfev: 36\n", 248 | " nit: 8\n", 249 | " njev: 9\n", 250 | " status: 0\n", 251 | " success: True\n", 252 | " x: array([1.00000573, 1.00001265])\n" 253 | ] 254 | } 255 | ], 256 | "source": [ 257 | "print optimize.minimize(f, [2,2], method='BFGS')" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": 43, 263 | "metadata": {}, 264 | "outputs": [ 265 | { 266 | "name": "stdout", 267 | "output_type": "stream", 268 | "text": [ 269 | " final_simplex: (array([[0.99998568, 0.99996682],\n", 270 | " [1.00002149, 1.00004744],\n", 271 | " [1.0000088 , 1.00003552]]), array([1.23119954e-10, 2.50768082e-10, 3.59639951e-10]))\n", 272 | " fun: 1.2311995365407462e-10\n", 273 | " message: 'Optimization terminated successfully.'\n", 274 | " nfev: 91\n", 275 | " nit: 46\n", 276 | " status: 0\n", 277 | " success: True\n", 278 | " x: array([0.99998568, 0.99996682])\n" 279 | ] 280 | } 281 | ], 282 | "source": [ 283 | "print optimize.minimize(f, [2,2], method='Nelder-Mead')" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [] 292 | } 293 | ], 294 | "metadata": { 295 | "kernelspec": { 296 | "display_name": "Python 2", 297 | "language": "python", 298 | "name": "python2" 299 | }, 300 | "language_info": { 301 | "codemirror_mode": { 302 | "name": "ipython", 303 | "version": 2 304 | }, 305 | "file_extension": ".py", 306 | "mimetype": "text/x-python", 307 | "name": "python", 308 | "nbconvert_exporter": "python", 309 | "pygments_lexer": "ipython2", 310 | "version": "2.7.16" 311 | } 312 | }, 313 | "nbformat": 4, 314 | "nbformat_minor": 2 315 | } 316 | -------------------------------------------------------------------------------- /week2/cat_work (Python 3).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 14, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "[['in', 'comparison', 'to', 'dogs', 'cats', 'have', 'not', 'undergone', 'major', 'changes', 'during', 'the', 'domestication', 'process'], ['as', 'cat', 'simply', 'catenates', 'streams', 'of', 'bytes', 'it', 'can', 'be', 'also', 'used', 'to', 'concatenate', 'binary', 'files', 'where', 'it', 'will', 'just', 'concatenate', 'sequence', 'of', 'bytes'], ['a', 'common', 'interactive', 'use', 'of', 'cat', 'for', 'a', 'single', 'file', 'is', 'to', 'output', 'the', 'content', 'of', 'a', 'file', 'to', 'standard', 'output'], ['cats', 'can', 'hear', 'sounds', 'too', 'faint', 'or', 'too', 'high', 'in', 'frequency', 'for', 'human', 'ears', 'such', 'as', 'those', 'made', 'by', 'mice', 'and', 'other', 'small', 'animals'], ['in', 'one', 'people', 'deliberately', 'tamed', 'cats', 'in', 'a', 'process', 'of', 'artificial', 'selection', 'as', 'they', 'were', 'useful', 'predators', 'of', 'vermin'], ['the', 'domesticated', 'cat', 'and', 'its', 'closest', 'wild', 'ancestor', 'are', 'both', 'diploid', 'organisms', 'that', 'possess', 'chromosomes', 'and', 'roughly', 'genes'], ['domestic', 'cats', 'are', 'similar', 'in', 'size', 'to', 'the', 'other', 'members', 'of', 'the', 'genus', 'felis', 'typically', 'weighing', 'between', 'and', 'kg', 'and', 'lb'], ['however', 'if', 'the', 'output', 'is', 'piped', 'or', 'redirected', 'cat', 'is', 'unnecessary'], ['cat', 'with', 'one', 'named', 'file', 'is', 'safer', 'where', 'human', 'error', 'is', 'a', 'concern', 'one', 'wrong', 'use', 'of', 'the', 'default', 'redirection', 'symbol', 'instead', 'of', 'often', 'adjacent', 'on', 'keyboards', 'may', 'permanently', 'delete', 'the', 'file', 'you', 'were', 'just', 'needing', 'to', 'read'], ['in', 'terms', 'of', 'legibility', 'a', 'sequence', 'of', 'commands', 'starting', 'with', 'cat', 'and', 'connected', 'by', 'pipes', 'has', 'a', 'clear', 'left', 'to', 'right', 'flow', 'of', 'information'], ['cat', 'command', 'is', 'one', 'of', 'the', 'basic', 'commands', 'that', 'you', 'learned', 'when', 'you', 'started', 'in', 'the', 'unix', 'linux', 'world'], ['using', 'cat', 'command', 'the', 'lines', 'received', 'from', 'stdin', 'can', 'be', 'redirected', 'to', 'a', 'new', 'file', 'using', 'redirection', 'symbols'], ['when', 'you', 'type', 'simply', 'cat', 'command', 'without', 'any', 'arguments', 'it', 'just', 'receives', 'the', 'stdin', 'content', 'and', 'displays', 'it', 'in', 'the', 'stdout'], ['leopard', 'was', 'released', 'on', 'october', 'as', 'the', 'successor', 'of', 'tiger', 'version', 'and', 'is', 'available', 'in', 'two', 'editions'], ['according', 'to', 'apple', 'leopard', 'contains', 'over', 'changes', 'and', 'enhancements', 'over', 'its', 'predecessor', 'mac', 'os', 'x', 'tiger'], ['as', 'of', 'mid', 'some', 'apple', 'computers', 'have', 'firmware', 'factory', 'installed', 'which', 'will', 'no', 'longer', 'allow', 'installation', 'of', 'mac', 'os', 'x', 'leopard'], ['since', 'apple', 'moved', 'to', 'using', 'intel', 'processors', 'in', 'their', 'computers', 'the', 'osx', 'community', 'has', 'developed', 'and', 'now', 'also', 'allows', 'mac', 'os', 'x', 'tiger', 'and', 'later', 'releases', 'to', 'be', 'installed', 'on', 'non', 'apple', 'x', 'based', 'computers'], ['os', 'x', 'mountain', 'lion', 'was', 'released', 'on', 'july', 'for', 'purchase', 'and', 'download', 'through', 'apple', 's', 'mac', 'app', 'store', 'as', 'part', 'of', 'a', 'switch', 'to', 'releasing', 'os', 'x', 'versions', 'online', 'and', 'every', 'year'], ['apple', 'has', 'released', 'a', 'small', 'patch', 'for', 'the', 'three', 'most', 'recent', 'versions', 'of', 'safari', 'running', 'on', 'os', 'x', 'yosemite', 'mavericks', 'and', 'mountain', 'lion'], ['the', 'mountain', 'lion', 'release', 'marks', 'the', 'second', 'time', 'apple', 'has', 'offered', 'an', 'incremental', 'upgrade', 'rather', 'than', 'releasing', 'a', 'new', 'cat', 'entirely'], ['mac', 'os', 'x', 'mountain', 'lion', 'installs', 'in', 'place', 'so', 'you', 'won', 't', 'need', 'to', 'create', 'a', 'separate', 'disk', 'or', 'run', 'the', 'installation', 'off', 'an', 'external', 'drive'], ['the', 'fifth', 'major', 'update', 'to', 'mac', 'os', 'x', 'leopard', 'contains', 'such', 'a', 'mountain', 'of', 'features', 'more', 'than', 'by', 'apple', 's', 'count']]\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "import numpy as np\n", 18 | "from scipy import spatial\n", 19 | "# Открываем файл и считываем строки в массив, обрезая мусор и приводя к нижнему регистру\n", 20 | "d = [] # массив для хранения предложений текста в виде строк (далее массива строк)\n", 21 | "n = 0 # число строк в файле\n", 22 | "with open('sentences.txt') as file:\n", 23 | " for line in file:\n", 24 | " n += 1\n", 25 | " d.append(line.strip().lower()) # считываем строчки файла, приводя их к нижнему регистру\n", 26 | "#print(d[:6])\n", 27 | "\n", 28 | "import re # импортируем библиотеку для работы с регулярными выражениями\n", 29 | "for i in range(len(d)): # пробегаем каждый элемент и разбиваем его регуляркой\n", 30 | " d[i] = re.split('[^a-z]', d[i])\n", 31 | " \n", 32 | " d[i] = [el for el in d[i] if el != ''] # удаляем пустые строки с помощью list comprehension\n", 33 | "print(d)" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 7, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "name": "stdout", 43 | "output_type": "stream", 44 | "text": [ 45 | "{'in': 11, 'comparison': 1, 'to': 14, 'dogs': 1, 'cats': 4, 'have': 2, 'not': 1, 'undergone': 1, 'major': 2, 'changes': 2, 'during': 1, 'the': 20, 'domestication': 1, 'process': 2, 'as': 6, 'cat': 10, 'simply': 2, 'catenates': 1, 'streams': 1, 'of': 19, 'bytes': 2, 'it': 4, 'can': 3, 'be': 3, 'also': 2, 'used': 1, 'concatenate': 2, 'binary': 1, 'files': 1, 'where': 2, 'will': 2, 'just': 3, 'sequence': 2, 'a': 13, 'common': 1, 'interactive': 1, 'use': 2, 'for': 4, 'single': 1, 'file': 5, 'is': 7, 'output': 3, 'content': 2, 'standard': 1, 'hear': 1, 'sounds': 1, 'too': 2, 'faint': 1, 'or': 3, 'high': 1, 'frequency': 1, 'human': 2, 'ears': 1, 'such': 2, 'those': 1, 'made': 1, 'by': 3, 'mice': 1, 'and': 14, 'other': 2, 'small': 2, 'animals': 1, 'one': 4, 'people': 1, 'deliberately': 1, 'tamed': 1, 'artificial': 1, 'selection': 1, 'they': 1, 'were': 2, 'useful': 1, 'predators': 1, 'vermin': 1, 'domesticated': 1, 'its': 2, 'closest': 1, 'wild': 1, 'ancestor': 1, 'are': 2, 'both': 1, 'diploid': 1, 'organisms': 1, 'that': 2, 'possess': 1, 'chromosomes': 1, 'roughly': 1, 'genes': 1, 'domestic': 1, 'similar': 1, 'size': 1, 'members': 1, 'genus': 1, 'felis': 1, 'typically': 1, 'weighing': 1, 'between': 1, 'kg': 1, 'lb': 1, 'however': 1, 'if': 1, 'piped': 1, 'redirected': 2, 'unnecessary': 1, 'with': 2, 'named': 1, 'safer': 1, 'error': 1, 'concern': 1, 'wrong': 1, 'default': 1, 'redirection': 2, 'symbol': 1, 'instead': 1, 'often': 1, 'adjacent': 1, 'on': 5, 'keyboards': 1, 'may': 1, 'permanently': 1, 'delete': 1, 'you': 5, 'needing': 1, 'read': 1, 'terms': 1, 'legibility': 1, 'commands': 2, 'starting': 1, 'connected': 1, 'pipes': 1, 'has': 4, 'clear': 1, 'left': 1, 'right': 1, 'flow': 1, 'information': 1, 'command': 3, 'basic': 1, 'learned': 1, 'when': 2, 'started': 1, 'unix': 1, 'linux': 1, 'world': 1, 'using': 3, 'lines': 1, 'received': 1, 'from': 1, 'stdin': 2, 'new': 2, 'symbols': 1, 'type': 1, 'without': 1, 'any': 1, 'arguments': 1, 'receives': 1, 'displays': 1, 'stdout': 1, 'leopard': 4, 'was': 2, 'released': 3, 'october': 1, 'successor': 1, 'tiger': 3, 'version': 1, 'available': 1, 'two': 1, 'editions': 1, 'according': 1, 'apple': 8, 'contains': 2, 'over': 2, 'enhancements': 1, 'predecessor': 1, 'mac': 6, 'os': 8, 'x': 9, 'mid': 1, 'some': 1, 'computers': 3, 'firmware': 1, 'factory': 1, 'installed': 2, 'which': 1, 'no': 1, 'longer': 1, 'allow': 1, 'installation': 2, 'since': 1, 'moved': 1, 'intel': 1, 'processors': 1, 'their': 1, 'osx': 1, 'community': 1, 'developed': 1, 'now': 1, 'allows': 1, 'later': 1, 'releases': 1, 'non': 1, 'based': 1, 'mountain': 5, 'lion': 4, 'july': 1, 'purchase': 1, 'download': 1, 'through': 1, 's': 2, 'app': 1, 'store': 1, 'part': 1, 'switch': 1, 'releasing': 2, 'versions': 2, 'online': 1, 'every': 1, 'year': 1, 'patch': 1, 'three': 1, 'most': 1, 'recent': 1, 'safari': 1, 'running': 1, 'yosemite': 1, 'mavericks': 1, 'release': 1, 'marks': 1, 'second': 1, 'time': 1, 'offered': 1, 'an': 2, 'incremental': 1, 'upgrade': 1, 'rather': 1, 'than': 2, 'entirely': 1, 'installs': 1, 'place': 1, 'so': 1, 'won': 1, 't': 1, 'need': 1, 'create': 1, 'separate': 1, 'disk': 1, 'run': 1, 'off': 1, 'external': 1, 'drive': 1, 'fifth': 1, 'update': 1, 'features': 1, 'more': 1, 'count': 1}\n" 46 | ] 47 | } 48 | ], 49 | "source": [ 50 | "fr = dict() # словарь числа вхождений слов в тексте\n", 51 | "for el_d in d: # бежим по внешнему массиву\n", 52 | " for el in el_d: # по внутреннему массиву\n", 53 | " if el not in fr:\n", 54 | " fr[el] = 1 # если слова не было, заводим его\n", 55 | " else: \n", 56 | " fr[el] += 1 # если слово есть, прибавляем число вхождений\n", 57 | "print(fr)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 8, 63 | "metadata": {}, 64 | "outputs": [ 65 | { 66 | "name": "stdout", 67 | "output_type": "stream", 68 | "text": [ 69 | "254\n" 70 | ] 71 | } 72 | ], 73 | "source": [ 74 | "print(len(fr))" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 9, 80 | "metadata": {}, 81 | "outputs": [ 82 | { 83 | "name": "stdout", 84 | "output_type": "stream", 85 | "text": [ 86 | "['in', 'comparison', 'to', 'dogs', 'cats', 'have', 'not', 'undergone', 'major', 'changes', 'during', 'the', 'domestication', 'process', 'as', 'cat', 'simply', 'catenates', 'streams', 'of', 'bytes', 'it', 'can', 'be', 'also', 'used', 'concatenate', 'binary', 'files', 'where', 'will', 'just', 'sequence', 'a', 'common', 'interactive', 'use', 'for', 'single', 'file', 'is', 'output', 'content', 'standard', 'hear', 'sounds', 'too', 'faint', 'or', 'high', 'frequency', 'human', 'ears', 'such', 'those', 'made', 'by', 'mice', 'and', 'other', 'small', 'animals', 'one', 'people', 'deliberately', 'tamed', 'artificial', 'selection', 'they', 'were', 'useful', 'predators', 'vermin', 'domesticated', 'its', 'closest', 'wild', 'ancestor', 'are', 'both', 'diploid', 'organisms', 'that', 'possess', 'chromosomes', 'roughly', 'genes', 'domestic', 'similar', 'size', 'members', 'genus', 'felis', 'typically', 'weighing', 'between', 'kg', 'lb', 'however', 'if', 'piped', 'redirected', 'unnecessary', 'with', 'named', 'safer', 'error', 'concern', 'wrong', 'default', 'redirection', 'symbol', 'instead', 'often', 'adjacent', 'on', 'keyboards', 'may', 'permanently', 'delete', 'you', 'needing', 'read', 'terms', 'legibility', 'commands', 'starting', 'connected', 'pipes', 'has', 'clear', 'left', 'right', 'flow', 'information', 'command', 'basic', 'learned', 'when', 'started', 'unix', 'linux', 'world', 'using', 'lines', 'received', 'from', 'stdin', 'new', 'symbols', 'type', 'without', 'any', 'arguments', 'receives', 'displays', 'stdout', 'leopard', 'was', 'released', 'october', 'successor', 'tiger', 'version', 'available', 'two', 'editions', 'according', 'apple', 'contains', 'over', 'enhancements', 'predecessor', 'mac', 'os', 'x', 'mid', 'some', 'computers', 'firmware', 'factory', 'installed', 'which', 'no', 'longer', 'allow', 'installation', 'since', 'moved', 'intel', 'processors', 'their', 'osx', 'community', 'developed', 'now', 'allows', 'later', 'releases', 'non', 'based', 'mountain', 'lion', 'july', 'purchase', 'download', 'through', 's', 'app', 'store', 'part', 'switch', 'releasing', 'versions', 'online', 'every', 'year', 'patch', 'three', 'most', 'recent', 'safari', 'running', 'yosemite', 'mavericks', 'release', 'marks', 'second', 'time', 'offered', 'an', 'incremental', 'upgrade', 'rather', 'than', 'entirely', 'installs', 'place', 'so', 'won', 't', 'need', 'create', 'separate', 'disk', 'run', 'off', 'external', 'drive', 'fifth', 'update', 'features', 'more', 'count'] 254\n" 87 | ] 88 | } 89 | ], 90 | "source": [ 91 | "#Создаем список со словами, чтобы порядок не менялся\n", 92 | "words_list = list(fr)\n", 93 | "print(words_list, len(words_list))" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 26, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "#Создаем матрицу (Количество предложений)*(Количество уникальных слов)\n", 103 | "# элемент с индексом (i, j) в этой матрице должен быть равен количеству вхождений j-го слова в i-е предложение\n", 104 | "matrix = []\n", 105 | "diff = len(words_list) # количество уникальных слов\n", 106 | "for i in range(n):\n", 107 | " temp_list = []\n", 108 | " for j in range(diff):\n", 109 | " temp_list.append(d[i].count(words_list[j]))\n", 110 | " matrix.append(np.array(temp_list))\n" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 25, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "text/plain": [ 121 | "0" 122 | ] 123 | }, 124 | "execution_count": 25, 125 | "metadata": {}, 126 | "output_type": "execute_result" 127 | } 128 | ], 129 | "source": [ 130 | "d[0].count(words_list[243])" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 27, 136 | "metadata": {}, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "[array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,\n", 143 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 144 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 145 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 146 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 147 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 148 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 149 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 150 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 151 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 152 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 153 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2,\n", 154 | " 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 155 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 156 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 157 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 158 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 159 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 160 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 161 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 162 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 163 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 164 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), array([0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0,\n", 165 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1,\n", 166 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 167 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 168 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 169 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 170 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 171 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 172 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 173 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 174 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 175 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), array([1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\n", 176 | " 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,\n", 177 | " 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,\n", 178 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 179 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 180 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 181 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 182 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 183 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 184 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 185 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 186 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), array([2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 2, 0, 0,\n", 187 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 188 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,\n", 189 | " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 190 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 191 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 192 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 193 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 194 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 195 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 196 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", 197 | " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])]\n" 198 | ] 199 | } 200 | ], 201 | "source": [ 202 | "print(matrix[:5])" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": 22, 208 | "metadata": {}, 209 | "outputs": [ 210 | { 211 | "name": "stdout", 212 | "output_type": "stream", 213 | "text": [ 214 | "['in', 'comparison', 'to', 'dogs', 'cats', 'have', 'not', 'undergone', 'major', 'changes', 'during', 'the', 'domestication', 'process', 'as', 'cat', 'simply', 'catenates', 'streams', 'of', 'bytes', 'it', 'can', 'be', 'also', 'used', 'concatenate', 'binary', 'files', 'where', 'will', 'just', 'sequence', 'a', 'common', 'interactive', 'use', 'for', 'single', 'file', 'is', 'output', 'content', 'standard', 'hear', 'sounds', 'too', 'faint', 'or', 'high', 'frequency', 'human', 'ears', 'such', 'those', 'made', 'by', 'mice', 'and', 'other', 'small', 'animals', 'one', 'people', 'deliberately', 'tamed', 'artificial', 'selection', 'they', 'were', 'useful', 'predators', 'vermin', 'domesticated', 'its', 'closest', 'wild', 'ancestor', 'are', 'both', 'diploid', 'organisms', 'that', 'possess', 'chromosomes', 'roughly', 'genes', 'domestic', 'similar', 'size', 'members', 'genus', 'felis', 'typically', 'weighing', 'between', 'kg', 'lb', 'however', 'if', 'piped', 'redirected', 'unnecessary', 'with', 'named', 'safer', 'error', 'concern', 'wrong', 'default', 'redirection', 'symbol', 'instead', 'often', 'adjacent', 'on', 'keyboards', 'may', 'permanently', 'delete', 'you', 'needing', 'read', 'terms', 'legibility', 'commands', 'starting', 'connected', 'pipes', 'has', 'clear', 'left', 'right', 'flow', 'information', 'command', 'basic', 'learned', 'when', 'started', 'unix', 'linux', 'world', 'using', 'lines', 'received', 'from', 'stdin', 'new', 'symbols', 'type', 'without', 'any', 'arguments', 'receives', 'displays', 'stdout', 'leopard', 'was', 'released', 'october', 'successor', 'tiger', 'version', 'available', 'two', 'editions', 'according', 'apple', 'contains', 'over', 'enhancements', 'predecessor', 'mac', 'os', 'x', 'mid', 'some', 'computers', 'firmware', 'factory', 'installed', 'which', 'no', 'longer', 'allow', 'installation', 'since', 'moved', 'intel', 'processors', 'their', 'osx', 'community', 'developed', 'now', 'allows', 'later', 'releases', 'non', 'based', 'mountain', 'lion', 'july', 'purchase', 'download', 'through', 's', 'app', 'store', 'part', 'switch', 'releasing', 'versions', 'online', 'every', 'year', 'patch', 'three', 'most', 'recent', 'safari', 'running', 'yosemite', 'mavericks', 'release', 'marks', 'second', 'time', 'offered', 'an', 'incremental', 'upgrade', 'rather', 'than', 'entirely', 'installs', 'place', 'so', 'won', 't', 'need', 'create', 'separate', 'disk', 'run', 'off', 'external', 'drive', 'fifth', 'update', 'features', 'more', 'count']\n" 215 | ] 216 | } 217 | ], 218 | "source": [ 219 | "print(words_list)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 31, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "name": "stdout", 229 | "output_type": "stream", 230 | "text": [ 231 | "[0.0, 0.9527544408738466, 0.8644738145642124, 0.8951715163278082, 0.7770887149698589, 0.9402385695332803, 0.7327387580875756, 0.9258750683338899, 0.8842724875284311, 0.9055088817476932, 0.8328165362273942, 0.8804771390665607, 0.8396432548525454, 0.8703592552895671, 0.8740118423302576, 0.9442721787424647, 0.8406361854220809, 0.956644501523794, 0.9442721787424647, 0.8885443574849294, 0.8427572744917122, 0.8250364469440588] 22\n" 232 | ] 233 | } 234 | ], 235 | "source": [ 236 | "# массив для хранения косинусных расстояний для первого и остальных предложений \n", 237 | "result = [] \n", 238 | "for i in range(n):\n", 239 | " result.append(spatial.distance.cosine(matrix[0], matrix[i]))\n", 240 | "print(result, n)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [ 249 | "4 6" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [ 258 | "# Вывод индексов самых близких к первому предложений" 259 | ] 260 | } 261 | ], 262 | "metadata": { 263 | "kernelspec": { 264 | "display_name": "Python 3", 265 | "language": "python", 266 | "name": "python3" 267 | }, 268 | "language_info": { 269 | "codemirror_mode": { 270 | "name": "ipython", 271 | "version": 3 272 | }, 273 | "file_extension": ".py", 274 | "mimetype": "text/x-python", 275 | "name": "python", 276 | "nbconvert_exporter": "python", 277 | "pygments_lexer": "ipython3", 278 | "version": "3.7.3" 279 | } 280 | }, 281 | "nbformat": 4, 282 | "nbformat_minor": 2 283 | } 284 | -------------------------------------------------------------------------------- /week2/data_sample_example.tsv: -------------------------------------------------------------------------------- 1 | Name Birth City Position Иванов А.А. 22.03.1980 Москва Сорокин И.В. 07.08.1965 Волгоград инженер Белов М.М. 13.02.1980 Ростов менеджер Мельникова Д.С. 15.04.1985 Ростов Рыбина Е.П. 19.11.1985 Москва инженер Костров С.О. 31.05.1985 Москва стажер -------------------------------------------------------------------------------- /week2/dataset.tsv: -------------------------------------------------------------------------------- 1 | Name Birth City Position Иванов А.А. 22.03.1980 Москва Сорокин И.В. 07.08.1965 Волгоград инженер Белов М.М. 13.02.1980 Ростов менеджер Мельникова Д.С. 15.04.1985 Ростов Рыбина Е.П. 19.11.1985 Москва инженер Костров С.О. 31.05.1985 Москва стажер -------------------------------------------------------------------------------- /week2/from authors/data_sample_example.tsv: -------------------------------------------------------------------------------- 1 | Name Birth City Position Иванов А.А. 22.03.1980 Москва Сорокин И.В. 07.08.1965 Волгоград инженер Белов М.М. 13.02.1980 Ростов менеджер Мельникова Д.С. 15.04.1985 Ростов Рыбина Е.П. 19.11.1985 Москва инженер Костров С.О. 31.05.1985 Москва стажер -------------------------------------------------------------------------------- /week2/from authors/dataset.tsv: -------------------------------------------------------------------------------- 1 | Name Birth City Position Иванов А.А. 22.03.1980 Москва Сорокин И.В. 07.08.1965 Волгоград инженер Белов М.М. 13.02.1980 Ростов менеджер Мельникова Д.С. 15.04.1985 Ростов Рыбина Е.П. 19.11.1985 Москва инженер Костров С.О. 31.05.1985 Москва стажер -------------------------------------------------------------------------------- /week2/from authors/pandas_dataframe.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Библиотека Pandas" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## Data Frame" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": { 21 | "collapsed": true 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "import pandas as pd" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "#создание DataFrame по столбцам с помощью словарей\n", 37 | "frame = pd.DataFrame({'numbers':range(10), 'chars':['a']*10})" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "frame" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": { 53 | "collapsed": true 54 | }, 55 | "outputs": [], 56 | "source": [ 57 | "#создание DataFrame с помощью чтения данных из файла\n", 58 | "frame = pd.read_csv('dataset.tsv', header=0, sep='\\t')" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "frame" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "frame.columns" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [ 85 | "frame.shape" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": { 92 | "collapsed": true 93 | }, 94 | "outputs": [], 95 | "source": [ 96 | "new_line = {'Name':'Perov', 'Birth':'22.03.1990', 'City':'Penza'}" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "#добавление строки в DataFrame\n", 106 | "frame.append(new_line, ignore_index=True)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "#добавление строки в DataFrame\n", 116 | "frame = frame.append(new_line, ignore_index=True)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "frame" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "#добавление столбца в DataFrame\n", 135 | "frame['IsStudent'] = [False]*5 + [True]*2" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "frame" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": { 151 | "collapsed": true 152 | }, 153 | "outputs": [], 154 | "source": [ 155 | "#удаление строк DataFrame\n", 156 | "frame.drop([5,6], axis=0)" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "frame" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "#удаление строк DataFrame (inplace)\n", 177 | "frame.drop([5,6], axis=0, inplace=True)" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [ 186 | "frame" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": { 193 | "collapsed": true 194 | }, 195 | "outputs": [], 196 | "source": [ 197 | "#удаление столбца DataFrame (inplace)\n", 198 | "frame.drop('IsStudent', axis=1, inplace=True)" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [ 207 | "frame" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": { 214 | "collapsed": true 215 | }, 216 | "outputs": [], 217 | "source": [ 218 | "#запись DataFrame в файл\n", 219 | "frame.to_csv('updated_dataset.csv', sep=',', header=True, index=False)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": null, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "!cat updated_dataset.csv" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": { 235 | "collapsed": true 236 | }, 237 | "outputs": [], 238 | "source": [ 239 | "#аналог команды для пользователей Windows\n", 240 | "!more updated_dataset.csv" 241 | ] 242 | } 243 | ], 244 | "metadata": { 245 | "kernelspec": { 246 | "display_name": "Python 2", 247 | "language": "python", 248 | "name": "python2" 249 | }, 250 | "language_info": { 251 | "codemirror_mode": { 252 | "name": "ipython", 253 | "version": 2 254 | }, 255 | "file_extension": ".py", 256 | "mimetype": "text/x-python", 257 | "name": "python", 258 | "nbconvert_exporter": "python", 259 | "pygments_lexer": "ipython2", 260 | "version": "2.7.16" 261 | } 262 | }, 263 | "nbformat": 4, 264 | "nbformat_minor": 1 265 | } 266 | -------------------------------------------------------------------------------- /week2/from authors/pandas_indexing_selection.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Библиотека Pandas" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## Data Frame" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "import pandas as pd" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 3, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "#создание DataFrame с помощью чтения данных из файла\n", 33 | "frame = pd.read_csv('data_sample_example.tsv', header=0, sep='\\t')" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 4, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "data": { 43 | "text/html": [ 44 | "
\n", 45 | "\n", 46 | " \n", 47 | " \n", 48 | " \n", 49 | " \n", 50 | " \n", 51 | " \n", 52 | " \n", 53 | " \n", 54 | " \n", 55 | " \n", 56 | " \n", 57 | " \n", 58 | " \n", 59 | " \n", 60 | " \n", 61 | " \n", 62 | " \n", 63 | " \n", 64 | " \n", 65 | " \n", 66 | " \n", 67 | " \n", 68 | " \n", 69 | " \n", 70 | " \n", 71 | " \n", 72 | " \n", 73 | " \n", 74 | " \n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | " \n", 87 | " \n", 88 | " \n", 89 | " \n", 90 | " \n", 91 | " \n", 92 | " \n", 93 | " \n", 94 | " \n", 95 | " \n", 96 | " \n", 97 | " \n", 98 | " \n", 99 | "
NameBirthCityPosition
0Иванов А.А.22.03.1980МоскваNaN
1Сорокин И.В.07.08.1965Волгоградинженер
2Белов М.М.13.02.1980Ростовменеджер
3Мельникова Д.С.15.04.1985РостовNaN
4Рыбина Е.П.19.11.1985Москваинженер
5Костров С.О.31.05.1985Москвастажер
\n", 100 | "
" 101 | ], 102 | "text/plain": [ 103 | " Name Birth City Position\n", 104 | "0 Иванов А.А. 22.03.1980 Москва NaN\n", 105 | "1 Сорокин И.В. 07.08.1965 Волгоград инженер\n", 106 | "2 Белов М.М. 13.02.1980 Ростов менеджер\n", 107 | "3 Мельникова Д.С. 15.04.1985 Ростов NaN\n", 108 | "4 Рыбина Е.П. 19.11.1985 Москва инженер\n", 109 | "5 Костров С.О. 31.05.1985 Москва стажер" 110 | ] 111 | }, 112 | "execution_count": 4, 113 | "metadata": {}, 114 | "output_type": "execute_result" 115 | } 116 | ], 117 | "source": [ 118 | "frame" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 8, 124 | "metadata": {}, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/plain": [ 129 | "Name object\n", 130 | "Birth datetime64[ns]\n", 131 | "City object\n", 132 | "Position object\n", 133 | "dtype: object" 134 | ] 135 | }, 136 | "execution_count": 8, 137 | "metadata": {}, 138 | "output_type": "execute_result" 139 | } 140 | ], 141 | "source": [ 142 | "frame.dtypes" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 6, 148 | "metadata": { 149 | "collapsed": true 150 | }, 151 | "outputs": [], 152 | "source": [ 153 | "#изменение типа столбца с помощью функции apply\n", 154 | "frame.Birth = frame.Birth.apply(pd.to_datetime)" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 7, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "data": { 164 | "text/html": [ 165 | "
\n", 166 | "\n", 167 | " \n", 168 | " \n", 169 | " \n", 170 | " \n", 171 | " \n", 172 | " \n", 173 | " \n", 174 | " \n", 175 | " \n", 176 | " \n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | " \n", 218 | " \n", 219 | " \n", 220 | "
NameBirthCityPosition
0Иванов А.А.1980-03-22МоскваNaN
1Сорокин И.В.1965-07-08Волгоградинженер
2Белов М.М.1980-02-13Ростовменеджер
3Мельникова Д.С.1985-04-15РостовNaN
4Рыбина Е.П.1985-11-19Москваинженер
5Костров С.О.1985-05-31Москвастажер
\n", 221 | "
" 222 | ], 223 | "text/plain": [ 224 | " Name Birth City Position\n", 225 | "0 Иванов А.А. 1980-03-22 Москва NaN\n", 226 | "1 Сорокин И.В. 1965-07-08 Волгоград инженер\n", 227 | "2 Белов М.М. 1980-02-13 Ростов менеджер\n", 228 | "3 Мельникова Д.С. 1985-04-15 Ростов NaN\n", 229 | "4 Рыбина Е.П. 1985-11-19 Москва инженер\n", 230 | "5 Костров С.О. 1985-05-31 Москва стажер" 231 | ] 232 | }, 233 | "execution_count": 7, 234 | "metadata": {}, 235 | "output_type": "execute_result" 236 | } 237 | ], 238 | "source": [ 239 | "frame" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": null, 245 | "metadata": { 246 | "collapsed": true 247 | }, 248 | "outputs": [], 249 | "source": [ 250 | "frame.dtypes" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 10, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "name": "stdout", 260 | "output_type": "stream", 261 | "text": [ 262 | "\n", 263 | "Int64Index: 6 entries, 0 to 5\n", 264 | "Data columns (total 4 columns):\n", 265 | "Name 6 non-null object\n", 266 | "Birth 6 non-null datetime64[ns]\n", 267 | "City 6 non-null object\n", 268 | "Position 4 non-null object\n", 269 | "dtypes: datetime64[ns](1), object(3)\n", 270 | "memory usage: 240.0+ bytes\n" 271 | ] 272 | } 273 | ], 274 | "source": [ 275 | "frame.info()" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 11, 281 | "metadata": {}, 282 | "outputs": [ 283 | { 284 | "data": { 285 | "text/html": [ 286 | "
\n", 287 | "\n", 288 | " \n", 289 | " \n", 290 | " \n", 291 | " \n", 292 | " \n", 293 | " \n", 294 | " \n", 295 | " \n", 296 | " \n", 297 | " \n", 298 | " \n", 299 | " \n", 300 | " \n", 301 | " \n", 302 | " \n", 303 | " \n", 304 | " \n", 305 | " \n", 306 | " \n", 307 | " \n", 308 | " \n", 309 | " \n", 310 | " \n", 311 | " \n", 312 | " \n", 313 | " \n", 314 | " \n", 315 | " \n", 316 | " \n", 317 | " \n", 318 | " \n", 319 | " \n", 320 | " \n", 321 | " \n", 322 | " \n", 323 | " \n", 324 | " \n", 325 | " \n", 326 | " \n", 327 | " \n", 328 | " \n", 329 | " \n", 330 | " \n", 331 | " \n", 332 | " \n", 333 | " \n", 334 | " \n", 335 | " \n", 336 | " \n", 337 | " \n", 338 | " \n", 339 | " \n", 340 | " \n", 341 | "
NameBirthCityPosition
0Иванов А.А.1980-03-22Москваразнорабочий
1Сорокин И.В.1965-07-08Волгоградинженер
2Белов М.М.1980-02-13Ростовменеджер
3Мельникова Д.С.1985-04-15Ростовразнорабочий
4Рыбина Е.П.1985-11-19Москваинженер
5Костров С.О.1985-05-31Москвастажер
\n", 342 | "
" 343 | ], 344 | "text/plain": [ 345 | " Name Birth City Position\n", 346 | "0 Иванов А.А. 1980-03-22 Москва разнорабочий\n", 347 | "1 Сорокин И.В. 1965-07-08 Волгоград инженер\n", 348 | "2 Белов М.М. 1980-02-13 Ростов менеджер\n", 349 | "3 Мельникова Д.С. 1985-04-15 Ростов разнорабочий\n", 350 | "4 Рыбина Е.П. 1985-11-19 Москва инженер\n", 351 | "5 Костров С.О. 1985-05-31 Москва стажер" 352 | ] 353 | }, 354 | "execution_count": 11, 355 | "metadata": {}, 356 | "output_type": "execute_result" 357 | } 358 | ], 359 | "source": [ 360 | "#заполнение пропущенных значений с помощью метода fillna\n", 361 | "frame.fillna('разнорабочий')" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": 12, 367 | "metadata": { 368 | "collapsed": true 369 | }, 370 | "outputs": [], 371 | "source": [ 372 | "#заполнение пропущенных значений с помощью метода fillna (inplace)\n", 373 | "frame.fillna('разнорабочий', inplace=True)" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": null, 379 | "metadata": { 380 | "collapsed": true 381 | }, 382 | "outputs": [], 383 | "source": [ 384 | "frame" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": { 391 | "collapsed": true 392 | }, 393 | "outputs": [], 394 | "source": [ 395 | "frame.Position" 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "execution_count": null, 401 | "metadata": { 402 | "collapsed": true 403 | }, 404 | "outputs": [], 405 | "source": [ 406 | "frame[['Position']]" 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": null, 412 | "metadata": { 413 | "collapsed": true 414 | }, 415 | "outputs": [], 416 | "source": [ 417 | "frame[['Name', 'Position']]" 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": null, 423 | "metadata": { 424 | "collapsed": true 425 | }, 426 | "outputs": [], 427 | "source": [ 428 | "frame[:3] #выбираем первые три записи" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": null, 434 | "metadata": { 435 | "collapsed": true 436 | }, 437 | "outputs": [], 438 | "source": [ 439 | "frame[-3:] #выбираем три послдение записи" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": null, 445 | "metadata": { 446 | "collapsed": true 447 | }, 448 | "outputs": [], 449 | "source": [ 450 | "frame.loc[[0,1,2], [\"Name\", \"City\"]] #работает на основе имен" 451 | ] 452 | }, 453 | { 454 | "cell_type": "code", 455 | "execution_count": null, 456 | "metadata": { 457 | "collapsed": true 458 | }, 459 | "outputs": [], 460 | "source": [ 461 | "frame.iloc[[1,3,5], [0,1]] #работает на основе позиций" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": null, 467 | "metadata": { 468 | "collapsed": true 469 | }, 470 | "outputs": [], 471 | "source": [ 472 | "frame.ix[[0,1,2], [\"Name\", \"City\"]] #поддерживает и имена и позиции (пример с именами)" 473 | ] 474 | }, 475 | { 476 | "cell_type": "code", 477 | "execution_count": null, 478 | "metadata": { 479 | "collapsed": true 480 | }, 481 | "outputs": [], 482 | "source": [ 483 | "frame.ix[[0,1,2], [0,1]] #поддерживает и имена и позиции (пример с позициями)" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": null, 489 | "metadata": { 490 | "collapsed": true 491 | }, 492 | "outputs": [], 493 | "source": [ 494 | "#выбираем строки, которые удовлетворяют условию frame.Birth >= pd.datetime(1985,1,1)\n", 495 | "frame[frame.Birth >= pd.datetime(1985,1,1)]" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": null, 501 | "metadata": { 502 | "collapsed": true 503 | }, 504 | "outputs": [], 505 | "source": [ 506 | "#выбираем строки, удовлетворяющие пересечению условий\n", 507 | "frame[(frame.Birth >= pd.datetime(1985,1,1)) &\n", 508 | " (frame.City != 'Москва')]" 509 | ] 510 | }, 511 | { 512 | "cell_type": "code", 513 | "execution_count": null, 514 | "metadata": { 515 | "collapsed": true 516 | }, 517 | "outputs": [], 518 | "source": [ 519 | "#выбираем строки, удовлетворяющие объединению условий\n", 520 | "frame[(frame.Birth >= pd.datetime(1985,1,1)) |\n", 521 | " (frame.City == 'Волгоград')]" 522 | ] 523 | } 524 | ], 525 | "metadata": { 526 | "kernelspec": { 527 | "display_name": "Python 2", 528 | "language": "python", 529 | "name": "python2" 530 | }, 531 | "language_info": { 532 | "codemirror_mode": { 533 | "name": "ipython", 534 | "version": 2 535 | }, 536 | "file_extension": ".py", 537 | "mimetype": "text/x-python", 538 | "name": "python", 539 | "nbconvert_exporter": "python", 540 | "pygments_lexer": "ipython2", 541 | "version": "2.7.16" 542 | } 543 | }, 544 | "nbformat": 4, 545 | "nbformat_minor": 1 546 | } 547 | -------------------------------------------------------------------------------- /week2/from authors/vector_operations.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# `NumPy`: векторы и операции над ними\n", 8 | "---" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "В этом ноутбуке нам понадобятся библиотека `NumPy`. Для удобства импортируем ее под более коротким именем:" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 5, 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "import numpy as np" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "## 1. Создание векторов" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "Самый простой способ создать вектор в `NumPy` — задать его явно с помощью __`numpy.array(list, dtype=None, ...)`__.\n", 39 | "\n", 40 | "Параметр __`list`__ задает итерируемый объект, из которого можно создать вектор. Например, в качестве этого параметра можно задать список чисел. Параметр __`dtype`__ задает тип значений вектора, например, __`float`__ — для вещественных значений и __`int`__ — для целочисленных. Если этот параметр не задан, то тип данных будет определен из типа элементов первого аргумента. " 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 2, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "name": "stdout", 50 | "output_type": "stream", 51 | "text": [ 52 | "Вектор:\n", 53 | "[1 2 3 4]\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "a = np.array([1, 2, 3, 4])\n", 59 | "print 'Вектор:\\n', a" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 3, 65 | "metadata": {}, 66 | "outputs": [ 67 | { 68 | "name": "stdout", 69 | "output_type": "stream", 70 | "text": [ 71 | "Вещественный вектор:\n", 72 | "[ 1. 2. 3. 4. 5.]\n" 73 | ] 74 | } 75 | ], 76 | "source": [ 77 | "b = np.array([1, 2, 3, 4, 5], dtype=float)\n", 78 | "print 'Вещественный вектор:\\n', b" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 4, 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "name": "stdout", 88 | "output_type": "stream", 89 | "text": [ 90 | "Булевский вектор:\n", 91 | "[ True False True]\n" 92 | ] 93 | } 94 | ], 95 | "source": [ 96 | "c = np.array([True, False, True], dtype=bool)\n", 97 | "print 'Булевский вектор:\\n', c" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Тип значений вектора можно узнать с помощью __`numpy.ndarray.dtype`__:" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 5, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "name": "stdout", 114 | "output_type": "stream", 115 | "text": [ 116 | "Тип булевского вектора:\n", 117 | "bool\n" 118 | ] 119 | } 120 | ], 121 | "source": [ 122 | "print 'Тип булевского вектора:\\n', c.dtype" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "Другим способом задания вектора является функция __`numpy.arange(([start, ]stop, [step, ]...)`__, которая задает последовательность чисел заданного типа из промежутка __[`start`, `stop`)__ через шаг __`step`__:" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 6, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "name": "stdout", 139 | "output_type": "stream", 140 | "text": [ 141 | "Вектор чисел от 10 до 20 с шагом 2:\n", 142 | "[10 12 14 16 18]\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "d = np.arange(start=10, stop=20, step=2) # последнее значение не включается!\n", 148 | "print 'Вектор чисел от 10 до 20 с шагом 2:\\n', d" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 7, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "name": "stdout", 158 | "output_type": "stream", 159 | "text": [ 160 | "Вещественный вектор чисел от 0 до 1 с шагом 0.3:\n", 161 | "[ 0. 0.3 0.6 0.9]\n" 162 | ] 163 | } 164 | ], 165 | "source": [ 166 | "f = np.arange(start=0, stop=1, step=0.3, dtype=float)\n", 167 | "print 'Вещественный вектор чисел от 0 до 1 с шагом 0.3:\\n', f" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "По сути вектор в `NumPy` является одномерным массивом, что соответствует интуитивному определению вектора:" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 8, 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "name": "stdout", 184 | "output_type": "stream", 185 | "text": [ 186 | "1\n" 187 | ] 188 | } 189 | ], 190 | "source": [ 191 | "print c.ndim # количество размерностей" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 9, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "name": "stdout", 201 | "output_type": "stream", 202 | "text": [ 203 | "(3,)\n" 204 | ] 205 | } 206 | ], 207 | "source": [ 208 | "print c.shape # shape фактически задает длину вектора " 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": {}, 214 | "source": [ 215 | "__Обратите внимание:__ _вектор _и одномерный массив тождественные понятия в `NumPy`. Помимо этого, также существуют понятия _вектор-столбец_ и _вектор-строка_, которые, несмотря на то что математически задают один и тот же объект, являются двумерными массивами и имеют другое значение поля __`shape`__ (в этом случае поле состоит из двух чисел, одно из которых равно единице). Эти тонкости будут рассмотрены в следующем уроке." 216 | ] 217 | }, 218 | { 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "Более подробно о том, как создавать векторы в `NumPy`, \n", 223 | "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.1/user/basics.creation.html)." 224 | ] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "metadata": {}, 229 | "source": [ 230 | "## 2. Операции над векторами" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "Векторы в `NumPy` можно складывать, вычитать, умножать на число и умножать на другой вектор (покоординатно):" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 10, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "name": "stdout", 247 | "output_type": "stream", 248 | "text": [ 249 | "Вектор a: [1 2 3]\n", 250 | "Вектор b: [6 5 4]\n", 251 | "Число k: 2\n" 252 | ] 253 | } 254 | ], 255 | "source": [ 256 | "a = np.array([1, 2, 3])\n", 257 | "b = np.array([6, 5, 4])\n", 258 | "k = 2\n", 259 | "\n", 260 | "print 'Вектор a:', a\n", 261 | "print 'Вектор b:', b\n", 262 | "print 'Число k:', k" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 11, 268 | "metadata": {}, 269 | "outputs": [ 270 | { 271 | "name": "stdout", 272 | "output_type": "stream", 273 | "text": [ 274 | "Сумма a и b:\n", 275 | "[7 7 7]\n" 276 | ] 277 | } 278 | ], 279 | "source": [ 280 | "print 'Сумма a и b:\\n', a + b" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 12, 286 | "metadata": {}, 287 | "outputs": [ 288 | { 289 | "name": "stdout", 290 | "output_type": "stream", 291 | "text": [ 292 | "Разность a и b:\n", 293 | "[-5 -3 -1]\n" 294 | ] 295 | } 296 | ], 297 | "source": [ 298 | "print 'Разность a и b:\\n', a - b" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 13, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "name": "stdout", 308 | "output_type": "stream", 309 | "text": [ 310 | "Покоординатное умножение a и b:\n", 311 | "[ 6 10 12]\n" 312 | ] 313 | } 314 | ], 315 | "source": [ 316 | "print 'Покоординатное умножение a и b:\\n', a * b " 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 14, 322 | "metadata": {}, 323 | "outputs": [ 324 | { 325 | "name": "stdout", 326 | "output_type": "stream", 327 | "text": [ 328 | "Умножение вектора на число (осуществляется покоординатно):\n", 329 | "[2 4 6]\n" 330 | ] 331 | } 332 | ], 333 | "source": [ 334 | "print 'Умножение вектора на число (осуществляется покоординатно):\\n', k * a " 335 | ] 336 | }, 337 | { 338 | "cell_type": "markdown", 339 | "metadata": {}, 340 | "source": [ 341 | "## 3. Нормы векторов" 342 | ] 343 | }, 344 | { 345 | "cell_type": "markdown", 346 | "metadata": {}, 347 | "source": [ 348 | "Вспомним некоторые нормы, которые можно ввести в пространстве $\\mathbb{R}^{n}$, и рассмотрим, с помощью каких библиотек и функций их можно вычислять в `NumPy`." 349 | ] 350 | }, 351 | { 352 | "cell_type": "markdown", 353 | "metadata": {}, 354 | "source": [ 355 | "### p-норма" 356 | ] 357 | }, 358 | { 359 | "cell_type": "markdown", 360 | "metadata": {}, 361 | "source": [ 362 | "p-норма (норма Гёльдера) для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n", 363 | "\n", 364 | "$$\n", 365 | "\\left\\Vert x \\right\\Vert_{p} = \\left( \\sum_{i=1}^n \\left| x_{i} \\right|^{p} \\right)^{1 / p},~p \\geq 1.\n", 366 | "$$" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "В частных случаях при:\n", 374 | "* $p = 1$ получаем $\\ell_{1}$ норму\n", 375 | "* $p = 2$ получаем $\\ell_{2}$ норму" 376 | ] 377 | }, 378 | { 379 | "cell_type": "markdown", 380 | "metadata": {}, 381 | "source": [ 382 | "Далее нам понабится модуль `numpy.linalg`, реализующий некоторые приложения линейной алгебры. Для вычисления различных норм мы используем функцию __`numpy.linalg.norm(x, ord=None, ...)`__, где __`x`__ — исходный вектор, __`ord`__ — параметр, определяющий норму (мы рассмотрим два варианта его значений — 1 и 2). Импортируем эту функцию:" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": 2, 388 | "metadata": {}, 389 | "outputs": [], 390 | "source": [ 391 | "from numpy.linalg import norm" 392 | ] 393 | }, 394 | { 395 | "cell_type": "markdown", 396 | "metadata": {}, 397 | "source": [ 398 | "### $\\ell_{1}$ норма" 399 | ] 400 | }, 401 | { 402 | "cell_type": "markdown", 403 | "metadata": {}, 404 | "source": [ 405 | "$\\ell_{1}$ норма \n", 406 | "(также известная как [манхэттенское расстояние](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D1%80%D0%BE%D0%B4%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D1%80%D1%82%D0%B0%D0%BB%D0%BE%D0%B2))\n", 407 | "для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n", 408 | "\n", 409 | "$$\n", 410 | " \\left\\Vert x \\right\\Vert_{1} = \\sum_{i=1}^n \\left| x_{i} \\right|.\n", 411 | "$$" 412 | ] 413 | }, 414 | { 415 | "cell_type": "markdown", 416 | "metadata": {}, 417 | "source": [ 418 | "Ей в функции __`numpy.linalg.norm(x, ord=None, ...)`__ соответствует параметр __`ord=1`__." 419 | ] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": 16, 424 | "metadata": {}, 425 | "outputs": [ 426 | { 427 | "name": "stdout", 428 | "output_type": "stream", 429 | "text": [ 430 | "Вектор a: [ 1 2 -3]\n" 431 | ] 432 | } 433 | ], 434 | "source": [ 435 | "a = np.array([1, 2, -3])\n", 436 | "print 'Вектор a:', a" 437 | ] 438 | }, 439 | { 440 | "cell_type": "code", 441 | "execution_count": 17, 442 | "metadata": {}, 443 | "outputs": [ 444 | { 445 | "name": "stdout", 446 | "output_type": "stream", 447 | "text": [ 448 | "L1 норма вектора a:\n", 449 | "6\n" 450 | ] 451 | } 452 | ], 453 | "source": [ 454 | "print 'L1 норма вектора a:\\n', norm(a, ord=1)" 455 | ] 456 | }, 457 | { 458 | "cell_type": "markdown", 459 | "metadata": {}, 460 | "source": [ 461 | "### $\\ell_{2}$ норма" 462 | ] 463 | }, 464 | { 465 | "cell_type": "markdown", 466 | "metadata": {}, 467 | "source": [ 468 | "$\\ell_{2}$ норма (также известная как евклидова норма)\n", 469 | "для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n", 470 | "\n", 471 | "$$\n", 472 | " \\left\\Vert x \\right\\Vert_{2} = \\sqrt{\\sum_{i=1}^n \\left( x_{i} \\right)^2}.\n", 473 | "$$" 474 | ] 475 | }, 476 | { 477 | "cell_type": "markdown", 478 | "metadata": {}, 479 | "source": [ 480 | "Ей в функции __`numpy.linalg.norm(x, ord=None, ...)`__ соответствует параметр __`ord=2`__." 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": 6, 486 | "metadata": {}, 487 | "outputs": [ 488 | { 489 | "name": "stdout", 490 | "output_type": "stream", 491 | "text": [ 492 | "Вектор a: [ 1 2 -3]\n" 493 | ] 494 | } 495 | ], 496 | "source": [ 497 | "a = np.array([1, 2, -3])\n", 498 | "print 'Вектор a:', a" 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": 7, 504 | "metadata": {}, 505 | "outputs": [ 506 | { 507 | "name": "stdout", 508 | "output_type": "stream", 509 | "text": [ 510 | "L2 норма вектора a:\n", 511 | "3.7416573867739413\n" 512 | ] 513 | } 514 | ], 515 | "source": [ 516 | "print 'L2 норма вектора a:\\n', norm(a, ord=2)" 517 | ] 518 | }, 519 | { 520 | "cell_type": "markdown", 521 | "metadata": {}, 522 | "source": [ 523 | "Более подробно о том, какие еще нормы (в том числе матричные) можно вычислить, см. [документацию](http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.norm.html). " 524 | ] 525 | }, 526 | { 527 | "cell_type": "markdown", 528 | "metadata": {}, 529 | "source": [ 530 | "## 4. Расстояния между векторами" 531 | ] 532 | }, 533 | { 534 | "cell_type": "markdown", 535 | "metadata": {}, 536 | "source": [ 537 | "Для двух векторов $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ и $y = (y_{1}, \\dots, y_{n}) \\in \\mathbb{R}^{n}$ $\\ell_{1}$ и $\\ell_{2}$ раccтояния вычисляются по следующим формулам соответственно:\n", 538 | "\n", 539 | "$$\n", 540 | " \\rho_{1}\\left( x, y \\right) = \\left\\Vert x - y \\right\\Vert_{1} = \\sum_{i=1}^n \\left| x_{i} - y_{i} \\right|\n", 541 | "$$\n", 542 | "\n", 543 | "$$\n", 544 | " \\rho_{2}\\left( x, y \\right) = \\left\\Vert x - y \\right\\Vert_{2} = \n", 545 | " \\sqrt{\\sum_{i=1}^n \\left( x_{i} - y_{i} \\right)^2}.\n", 546 | "$$" 547 | ] 548 | }, 549 | { 550 | "cell_type": "code", 551 | "execution_count": 20, 552 | "metadata": {}, 553 | "outputs": [ 554 | { 555 | "name": "stdout", 556 | "output_type": "stream", 557 | "text": [ 558 | "Вектор a: [ 1 2 -3]\n", 559 | "Вектор b: [-4 3 8]\n" 560 | ] 561 | } 562 | ], 563 | "source": [ 564 | "a = np.array([1, 2, -3])\n", 565 | "b = np.array([-4, 3, 8])\n", 566 | "print 'Вектор a:', a\n", 567 | "print 'Вектор b:', b" 568 | ] 569 | }, 570 | { 571 | "cell_type": "code", 572 | "execution_count": 21, 573 | "metadata": {}, 574 | "outputs": [ 575 | { 576 | "name": "stdout", 577 | "output_type": "stream", 578 | "text": [ 579 | "L1 расстояние между векторами a и b:\n", 580 | "17\n" 581 | ] 582 | } 583 | ], 584 | "source": [ 585 | "print 'L1 расстояние между векторами a и b:\\n', norm(a - b, ord=1)" 586 | ] 587 | }, 588 | { 589 | "cell_type": "code", 590 | "execution_count": 22, 591 | "metadata": {}, 592 | "outputs": [ 593 | { 594 | "name": "stdout", 595 | "output_type": "stream", 596 | "text": [ 597 | "L2 расстояние между векторами a и b:\n", 598 | "12.124355653\n" 599 | ] 600 | } 601 | ], 602 | "source": [ 603 | "print 'L2 расстояние между векторами a и b:\\n', norm(a - b, ord=2)" 604 | ] 605 | }, 606 | { 607 | "cell_type": "markdown", 608 | "metadata": {}, 609 | "source": [ 610 | "Также расстояние между векторами можно посчитать с помощью функции __`scipy.spatial.distance.cdist(XA, XB, metric='euclidean', p=2, ...)`__ из модуля `SciPy`, предназначенного для выполнения научных и инженерных расчётов. " 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": 8, 616 | "metadata": {}, 617 | "outputs": [], 618 | "source": [ 619 | "from scipy.spatial.distance import cdist" 620 | ] 621 | }, 622 | { 623 | "cell_type": "markdown", 624 | "metadata": {}, 625 | "source": [ 626 | "__`scipy.spatial.distance.cdist(...)`__ требует, чтобы размерность __`XA`__ и __`XB`__ была как минимум двумерная. По этой причине для использования этой функции необходимо преобразовать _векторы_, которые мы рассматриваем в этом ноутбуке, к _вектор-строкам_ с помощью способов, которые мы рассмотрим ниже. " 627 | ] 628 | }, 629 | { 630 | "cell_type": "markdown", 631 | "metadata": {}, 632 | "source": [ 633 | "Параметры __`XA, XB`__ — исходные вектор-строки, а __`metric`__ и __`p`__ задают метрику расстояния\n", 634 | "(более подробно о том, какие метрики можно использовать, см. [документацию](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.distance.cdist.html))." 635 | ] 636 | }, 637 | { 638 | "cell_type": "markdown", 639 | "metadata": {}, 640 | "source": [ 641 | "Первый способ из _вектора_ сделать _вектор-строку (вектор-столбец)_ — это использовать _метод_ __`array.reshape(shape)`__, где параметр __`shape`__ задает размерность вектора (кортеж чисел)." 642 | ] 643 | }, 644 | { 645 | "cell_type": "code", 646 | "execution_count": 24, 647 | "metadata": { 648 | "scrolled": true 649 | }, 650 | "outputs": [ 651 | { 652 | "name": "stdout", 653 | "output_type": "stream", 654 | "text": [ 655 | "Вектор a: [ 6 3 -5]\n", 656 | "Его размерность: (3,)\n", 657 | "Вектор b: [-1 0 7]\n", 658 | "Его размерность: (3,)\n" 659 | ] 660 | } 661 | ], 662 | "source": [ 663 | "a = np.array([6, 3, -5])\n", 664 | "b = np.array([-1, 0, 7])\n", 665 | "print 'Вектор a:', a\n", 666 | "print 'Его размерность:', a.shape\n", 667 | "print 'Вектор b:', b\n", 668 | "print 'Его размерность:', b.shape" 669 | ] 670 | }, 671 | { 672 | "cell_type": "code", 673 | "execution_count": 25, 674 | "metadata": {}, 675 | "outputs": [ 676 | { 677 | "name": "stdout", 678 | "output_type": "stream", 679 | "text": [ 680 | "После применения метода reshape:\n", 681 | "\n", 682 | "Вектор-строка a: [[ 6 3 -5]]\n", 683 | "Его размерность: (1, 3)\n", 684 | "Вектор-строка b: [[-1 0 7]]\n", 685 | "Его размерность: (1, 3)\n" 686 | ] 687 | } 688 | ], 689 | "source": [ 690 | "a = a.reshape((1, 3))\n", 691 | "b = b.reshape((1, 3))\n", 692 | "print 'После применения метода reshape:\\n'\n", 693 | "print 'Вектор-строка a:', a\n", 694 | "print 'Его размерность:', a.shape\n", 695 | "print 'Вектор-строка b:', b\n", 696 | "print 'Его размерность:', b.shape" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": 26, 702 | "metadata": {}, 703 | "outputs": [ 704 | { 705 | "name": "stdout", 706 | "output_type": "stream", 707 | "text": [ 708 | "Манхэттенское расстояние между a и b (через cdist): [[ 22.]]\n" 709 | ] 710 | } 711 | ], 712 | "source": [ 713 | "print 'Манхэттенское расстояние между a и b (через cdist):', cdist(a, b, metric='cityblock')" 714 | ] 715 | }, 716 | { 717 | "cell_type": "markdown", 718 | "metadata": {}, 719 | "source": [ 720 | "Заметим, что после применения этого метода размерность полученных вектор-строк будет равна __`shape`__. Следующий метод позволяет сделать такое же преобразование, но не изменяет размерность исходного вектора. " 721 | ] 722 | }, 723 | { 724 | "cell_type": "markdown", 725 | "metadata": {}, 726 | "source": [ 727 | "В `NumPy` к размерностям объектов можно добавлять фиктивные оси с помощью __`np.newaxis`__. Для того, чтобы понять, как это сделать, рассмотрим пример:" 728 | ] 729 | }, 730 | { 731 | "cell_type": "code", 732 | "execution_count": 27, 733 | "metadata": {}, 734 | "outputs": [ 735 | { 736 | "name": "stdout", 737 | "output_type": "stream", 738 | "text": [ 739 | "Вектор d: [ 3 0 8 9 -10]\n", 740 | "Его размерность: (5,)\n" 741 | ] 742 | } 743 | ], 744 | "source": [ 745 | "d = np.array([3, 0, 8, 9, -10])\n", 746 | "print 'Вектор d:', d\n", 747 | "print 'Его размерность:', d.shape" 748 | ] 749 | }, 750 | { 751 | "cell_type": "code", 752 | "execution_count": 28, 753 | "metadata": {}, 754 | "outputs": [ 755 | { 756 | "name": "stdout", 757 | "output_type": "stream", 758 | "text": [ 759 | "Вектор d с newaxis --> вектор-строка:\n", 760 | "[[ 3 0 8 9 -10]]\n", 761 | "Полученная размерность: (1, 5)\n", 762 | "Вектор d с newaxis --> вектор-столбец:\n", 763 | "[[ 3]\n", 764 | " [ 0]\n", 765 | " [ 8]\n", 766 | " [ 9]\n", 767 | " [-10]]\n", 768 | "Полученная размерность: (5, 1)\n" 769 | ] 770 | } 771 | ], 772 | "source": [ 773 | "print 'Вектор d с newaxis --> вектор-строка:\\n', d[np.newaxis, :]\n", 774 | "print 'Полученная размерность:', d[np.newaxis, :].shape\n", 775 | "\n", 776 | "print 'Вектор d с newaxis --> вектор-столбец:\\n', d[:, np.newaxis]\n", 777 | "print 'Полученная размерность:', d[:, np.newaxis].shape" 778 | ] 779 | }, 780 | { 781 | "cell_type": "markdown", 782 | "metadata": {}, 783 | "source": [ 784 | "Важно, что __`np.newaxis`__ добавляет к размерности ось, длина которой равна 1 (это и логично, так как количество элементов должно сохраняться). Таким образом, надо вставлять новую ось там, где нужна единица в размерности. " 785 | ] 786 | }, 787 | { 788 | "cell_type": "markdown", 789 | "metadata": {}, 790 | "source": [ 791 | "Теперь посчитаем расстояния с помощью __`scipy.spatial.distance.cdist(...)`__, используя __`np.newaxis`__ для преобразования векторов:" 792 | ] 793 | }, 794 | { 795 | "cell_type": "code", 796 | "execution_count": 29, 797 | "metadata": { 798 | "scrolled": true 799 | }, 800 | "outputs": [ 801 | { 802 | "name": "stdout", 803 | "output_type": "stream", 804 | "text": [ 805 | "Евклидово расстояние между a и b (через cdist): [[ 14.2126704]]\n" 806 | ] 807 | } 808 | ], 809 | "source": [ 810 | "a = np.array([6, 3, -5])\n", 811 | "b = np.array([-1, 0, 7])\n", 812 | "print 'Евклидово расстояние между a и b (через cdist):', cdist(a[np.newaxis, :], \n", 813 | " b[np.newaxis, :], \n", 814 | " metric='euclidean')" 815 | ] 816 | }, 817 | { 818 | "cell_type": "markdown", 819 | "metadata": {}, 820 | "source": [ 821 | "Эта функция также позволяет вычислять попарные расстояния между множествами векторов. Например, пусть у нас имеется матрица размера $m_{A} \\times n$. Мы можем рассматривать ее как описание некоторых $m_{A}$ наблюдений в $n$-мерном пространстве. Пусть также имеется еще одна аналогичная матрица размера $m_{B} \\times n$, где $m_{B}$ векторов в том же $n$-мерном пространстве. Часто необходимо посчитать попарные расстояния между векторами первого и второго множеств. В этом случае можно пользоваться функцией __`scipy.spatial.distance.cdist(XA, XB, metric='euclidean', p=2, ...)`__, где в качестве __`XA, XB`__ необходимо передать две описанные матрицы. Функция возвращает матрицу попарных расстояний размера $m_{A} \\times m_{B}$, где элемент матрицы на $[i, j]$-ой позиции равен расстоянию между $i$-тым вектором первого множества и $j$-ым вектором второго множества. \n", 822 | "\n", 823 | "В данном случае эта функция предподчительнее __`numpy.linalg.norm(...)`__, так как она вычисляет попарные расстояния быстрее и эффективнее. " 824 | ] 825 | }, 826 | { 827 | "cell_type": "markdown", 828 | "metadata": {}, 829 | "source": [ 830 | "## 5. Скалярное произведение и угол между векторами" 831 | ] 832 | }, 833 | { 834 | "cell_type": "code", 835 | "execution_count": 10, 836 | "metadata": {}, 837 | "outputs": [ 838 | { 839 | "name": "stdout", 840 | "output_type": "stream", 841 | "text": [ 842 | "Вектор a: [ 0 5 -1]\n", 843 | "Вектор b: [-4 9 3]\n" 844 | ] 845 | } 846 | ], 847 | "source": [ 848 | "a = np.array([0, 5, -1])\n", 849 | "b = np.array([-4, 9, 3])\n", 850 | "print 'Вектор a:', a\n", 851 | "print 'Вектор b:', b" 852 | ] 853 | }, 854 | { 855 | "cell_type": "markdown", 856 | "metadata": {}, 857 | "source": [ 858 | "Скалярное произведение в пространстве $\\mathbb{R}^{n}$ для двух векторов $x = (x_{1}, \\dots, x_{n})$ и $y = (y_{1}, \\dots, y_{n})$ определяется как:\n", 859 | "\n", 860 | "$$\n", 861 | "\\langle x, y \\rangle = \\sum_{i=1}^n x_{i} y_{i}.\n", 862 | "$$" 863 | ] 864 | }, 865 | { 866 | "cell_type": "markdown", 867 | "metadata": {}, 868 | "source": [ 869 | "Скалярное произведение двух векторов можно вычислять с помощью функции __`numpy.dot(a, b, ...)`__ или _метода_ __`vec1.dot(vec2)`__, где __`vec1`__ и __`vec2`__ — исходные векторы. Также эти функции подходят для матричного умножения, о котором речь пойдет в следующем уроке. " 870 | ] 871 | }, 872 | { 873 | "cell_type": "code", 874 | "execution_count": 31, 875 | "metadata": {}, 876 | "outputs": [ 877 | { 878 | "name": "stdout", 879 | "output_type": "stream", 880 | "text": [ 881 | "Скалярное произведение a и b (через функцию): 42\n" 882 | ] 883 | } 884 | ], 885 | "source": [ 886 | "print 'Скалярное произведение a и b (через функцию):', np.dot(a, b)" 887 | ] 888 | }, 889 | { 890 | "cell_type": "code", 891 | "execution_count": 32, 892 | "metadata": {}, 893 | "outputs": [ 894 | { 895 | "name": "stdout", 896 | "output_type": "stream", 897 | "text": [ 898 | "Скалярное произведение a и b (через метод): 42\n" 899 | ] 900 | } 901 | ], 902 | "source": [ 903 | "print 'Скалярное произведение a и b (через метод):', a.dot(b)" 904 | ] 905 | }, 906 | { 907 | "cell_type": "markdown", 908 | "metadata": {}, 909 | "source": [ 910 | "Длиной вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ называется квадратный корень из скалярного произведения, то есть длина равна евклидовой норме вектора:\n", 911 | "\n", 912 | "$$\n", 913 | "\\left| x \\right| = \\sqrt{\\langle x, x \\rangle} = \\sqrt{\\sum_{i=1}^n x_{i}^2} = \\left\\Vert x \\right\\Vert_{2}.\n", 914 | "$$" 915 | ] 916 | }, 917 | { 918 | "cell_type": "markdown", 919 | "metadata": {}, 920 | "source": [ 921 | "Теперь, когда мы знаем расстояние между двумя ненулевыми векторами и их длины, мы можем вычислить угол между ними через скалярное произведение:\n", 922 | "\n", 923 | "$$\n", 924 | "\\langle x, y \\rangle = \\left| x \\right| | y | \\cos(\\alpha)\n", 925 | "\\implies \\cos(\\alpha) = \\frac{\\langle x, y \\rangle}{\\left| x \\right| | y |},\n", 926 | "$$\n", 927 | "\n", 928 | "где $\\alpha \\in [0, \\pi]$ — угол между векторами $x$ и $y$." 929 | ] 930 | }, 931 | { 932 | "cell_type": "code", 933 | "execution_count": 11, 934 | "metadata": {}, 935 | "outputs": [ 936 | { 937 | "name": "stdout", 938 | "output_type": "stream", 939 | "text": [ 940 | "Косинус угла между a и b: 0.8000362836474323\n", 941 | "Сам угол: 0.6434406336093618\n" 942 | ] 943 | } 944 | ], 945 | "source": [ 946 | "cos_angle = np.dot(a, b) / norm(a) / norm(b)\n", 947 | "print 'Косинус угла между a и b:', cos_angle\n", 948 | "print 'Сам угол:', np.arccos(cos_angle)" 949 | ] 950 | }, 951 | { 952 | "cell_type": "markdown", 953 | "metadata": {}, 954 | "source": [ 955 | "Более подробно о том, как вычислять скалярное произведение в `NumPy`, \n", 956 | "см. [документацию](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html#matrix-and-vector-products)." 957 | ] 958 | } 959 | ], 960 | "metadata": { 961 | "anaconda-cloud": {}, 962 | "kernelspec": { 963 | "display_name": "Python 2", 964 | "language": "python", 965 | "name": "python2" 966 | }, 967 | "language_info": { 968 | "codemirror_mode": { 969 | "name": "ipython", 970 | "version": 2 971 | }, 972 | "file_extension": ".py", 973 | "mimetype": "text/x-python", 974 | "name": "python", 975 | "nbconvert_exporter": "python", 976 | "pygments_lexer": "ipython2", 977 | "version": "2.7.16" 978 | } 979 | }, 980 | "nbformat": 4, 981 | "nbformat_minor": 1 982 | } 983 | -------------------------------------------------------------------------------- /week2/sentences.txt: -------------------------------------------------------------------------------- 1 | In comparison to dogs, cats have not undergone major changes during the domestication process. 2 | As cat simply catenates streams of bytes, it can be also used to concatenate binary files, where it will just concatenate sequence of bytes. 3 | A common interactive use of cat for a single file is to output the content of a file to standard output. 4 | Cats can hear sounds too faint or too high in frequency for human ears, such as those made by mice and other small animals. 5 | In one, people deliberately tamed cats in a process of artificial selection, as they were useful predators of vermin. 6 | The domesticated cat and its closest wild ancestor are both diploid organisms that possess 38 chromosomes and roughly 20,000 genes. 7 | Domestic cats are similar in size to the other members of the genus Felis, typically weighing between 4 and 5 kg (8.8 and 11.0 lb). 8 | However, if the output is piped or redirected, cat is unnecessary. 9 | cat with one named file is safer where human error is a concern - one wrong use of the default redirection symbol ">" instead of "<" (often adjacent on keyboards) may permanently delete the file you were just needing to read. 10 | In terms of legibility, a sequence of commands starting with cat and connected by pipes has a clear left-to-right flow of information. 11 | Cat command is one of the basic commands that you learned when you started in the Unix / Linux world. 12 | Using cat command, the lines received from stdin can be redirected to a new file using redirection symbols. 13 | When you type simply cat command without any arguments, it just receives the stdin content and displays it in the stdout. 14 | Leopard was released on October 26, 2007 as the successor of Tiger (version 10.4), and is available in two editions. 15 | According to Apple, Leopard contains over 300 changes and enhancements over its predecessor, Mac OS X Tiger. 16 | As of Mid 2010, some Apple computers have firmware factory installed which will no longer allow installation of Mac OS X Leopard. 17 | Since Apple moved to using Intel processors in their computers, the OSx86 community has developed and now also allows Mac OS X Tiger and later releases to be installed on non-Apple x86-based computers. 18 | OS X Mountain Lion was released on July 25, 2012 for purchase and download through Apple's Mac App Store, as part of a switch to releasing OS X versions online and every year. 19 | Apple has released a small patch for the three most recent versions of Safari running on OS X Yosemite, Mavericks, and Mountain Lion. 20 | The Mountain Lion release marks the second time Apple has offered an incremental upgrade, rather than releasing a new cat entirely. 21 | Mac OS X Mountain Lion installs in place, so you won't need to create a separate disk or run the installation off an external drive. 22 | The fifth major update to Mac OS X, Leopard, contains such a mountain of features - more than 300 by Apple's count. 23 | -------------------------------------------------------------------------------- /week2/updated_dataset.csv: -------------------------------------------------------------------------------- 1 | Name,Birth,City,Position 2 | Иванов А.А.,22.03.1980,Москва, 3 | Сорокин И.В.,07.08.1965,Волгоград,инженер 4 | Белов М.М.,13.02.1980,Ростов,менеджер 5 | Мельникова Д.С.,15.04.1985,Ростов, 6 | -------------------------------------------------------------------------------- /week3/submission-1.txt: -------------------------------------------------------------------------------- 1 | 1.75 -11.9 -------------------------------------------------------------------------------- /week3/submission-2.txt: -------------------------------------------------------------------------------- 1 | -5 -11.0 -------------------------------------------------------------------------------- /week3/submission-3.txt: -------------------------------------------------------------------------------- 1 | -5 -11.0 -------------------------------------------------------------------------------- /Дополнительные материалы/linalg12.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/Дополнительные материалы/linalg12.pdf -------------------------------------------------------------------------------- /Дополнительные материалы/квартет.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pavelevandrei/MathAndPythonForDataAnalysis/7113acc9d0bd51044c69714473b5300bc59869aa/Дополнительные материалы/квартет.PNG --------------------------------------------------------------------------------