{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Двигаемся дальше\n", "\n", "## Работа с произвольными файлами\n", "\n", "Для того что бы обрабатывать данные с лабораторных работ, нужно что бы они как-то попали к вам в программу. Конечно можно просто ввести их непосредтсвенно в код программы (например так, `data = [1,2,3,4,5,6,7]`), но по многим практическим соброжениям это не удобно и неправильно. Корректным будет хранить данные в отдельных файлах и уметь считывать информацию из них. Способов считывать данные много, о более удобных для использования (но работающих только с определенными форматами файлов) мы поговорим в следующих разделах, а сейчас разберем универсальный способ работы с произвольным файлом. \n", "Файлы можно окрывать в двух режимах: \n", "\n", "* Текстовом: информация в файле интерпретируется как текст, и в данном мы оперируем данными как набором символов, например если в файл написано `123`, это не значит что там записанно число 123, а значит что там записаны символы `1`, `2`, `3`.\n", "* Бинарном: информация в файле интерпретируется как набор байтов и в данном случае мы оперируем отдельными байтами, которые мы потом можем интерперитовать как числа, символы или ещё что-то.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "' x y y_error\\n0 1.05923 0.0861431\\n0.0714286 0.913173 0.0859666\\n0.142857 0.954408 0.06095\\n0.214286 0.819393 0.0378351\\n0.285714 0.91041 0.07267\\n0.357143 0.73905 0.0580905\\n0.428571 0.80262 0.0656587\\n0.5 0.764531 0.0278336\\n0.571429 0.782643 0.0450629\\n0.642857 0.790794 0.0482949\\n0.714286 0.762573 0.0409075\\n0.785714 0.8131 0.0640749\\n0.857143 0.779934 0.0820886\\n0.928571 0.915171 0.082733\\n1 1.00332 0.0567224'" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fin = open(\"example_fit.txt\") # Окрываем файл\n", "text = fin.read() # Считываем его целиком\n", "fin.close() # Закрываем файл\n", "text " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как мы видим считанная из файла информация представлена как строка и для того чтобы получить из неё цифоры её надо будет обработать. Нам необязательно считывать файл целиком, мы можем делать это построчно или посимвольно, считывать данные можно не только с начала файла но и с произвольного места. Обращаю ваше внимание на операцию `fin.close()`, закрытие файла очень важно, не смотря на то что Python часто относиться к этому либерально, если вы не закроете файл то вы можете потерять данные при записи в файл или может возникнуть проблема с записью в этот файл. Для того что бы не иметь проблем с закрытием файлов нужно использовать *контекстный менеджер*." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open(\"temp.txt\", \"w\") as fout: # Переменная fout действует внутри контекста open\n", " fout.write(\"Текст\") # Пишим данные\n", " # Обрабите внимание что в текстовые файлы мы пишем текст, \n", " # поэтому нужно привести числовые данные к строкам" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как видно в этом примере для того что бы открыть файл на запись мы передали второй аргумент в функцию `open`. `\"w\"` означает что файл открыт на запись, **при этом сущетсвующующий файл перезаписывается**. Сущетсвуют различные режимы записи/чтения файла, если нужно совместить несколько режимов, они указываются вместе, например `\"rb\"` - октрывает файл на чтение в *бинарном* режиме. По умолчанию файл открывается на чтение в текстовом режиме." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Еще не много важных вещей о переменных и об объектах (дополнительный материал)\n", "\n", "В этом разделе мы поговорим о том что такое переменная. Все наши данные в программе представлены как некоторые *объекты*, которые находятся где-то в памяти компьютера. Так вот переменная ссылается на некий объект в памяти, на один и тот же объект могут ссылаться не сколько переменных. Расмотрим пример. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a : [1, 2, 3]\n", "b : [1, 2, 3]\n", "a : [1, 10, 3]\n" ] } ], "source": [ "a = [1,2,3]\n", "b = a\n", "print(\"a : {}\".format(a))\n", "print(\"b : {}\".format(b))\n", "b[1] = 10\n", "print(\"a : {}\".format(a))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Мы поменяли что-то в перменной `b`, а изменилась переменная `a`? Нет это не правильная точка зрения, и `a`, и `b` ссылаются на один и тот же список лежащий в памяти и поэтому неважно через какую переменную мы к нему обращащемся. Если же мы хотит записать в gпеременную `b` новый объект являющийся *копией* сущетсвующего объекта, то мы должны использовать методы `copy` (создает поверхностную копию) и `deepcopy` (создает полную копию) (о разнице в этих методах можно прочесть [здесь](https://docs.python.org/3.7/library/copy.html)).\n", "\n", "Так же следует знать что объекты в Python бывают изменяемые и не изменяемые.\n", "Они отличаются тем, что содержимое изменяемых объектов может быть изменено (перезаписанно в памяти), а неизменяемых нет. Расмотрим пример:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "String\n", "STRING\n" ] } ], "source": [ "a = \"String\" # строка не изменяемый объект\n", "b = a.upper() # Метод upper нужен для перевода данных в верхний регистр\n", "print(a) # Строка a не изменилась\n", "print(b) # Строка b это новый объект строки, никак не связанный с предыдущим" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = [5,4,3,2,1] # список изменемый объект\n", "a.sort() # При сортировке не создался новый список, с отсортированными значениями,\n", " # а изменился сущетсвующий объект\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Другим существенным отличием в неизменяемых от изменяемых объектов, является их поведение при передачи в функцию. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3]\n", "[1, 2, 3, 0]\n" ] } ], "source": [ "a = [1,2,3]\n", "\n", "print(a)\n", "\n", "def change_list(a):\n", " a.append(0) # Добавляем новый элементв в a\n", " \n", "change_list(a)\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "В нашу функцию передался иммено наш объект, а не его копия и функция может изменить содержимое объекта. Все пользовательские типы являются изменяемыми объектами. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Структуры данных: словари и кортежи\n", "\n", "Пришло время познакомится с ещё двумя структурами данных.\n", "\n", "### Кортежи\n", "\n", "Кортежи (tuple) - неизменяемые списки. Для них доступны все операции над списками, не изменяющие список (сложение, умножение на число, методы `index()` и `count()` и некоторые другие операции). Можно также по-разному менять элементы местами и так далее." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 2, 3, 4, 5)\n", "(1, 2, 3, 4, 5, 1, 2, 3)\n", "(1, 2, 3, 4, 5, 1, 2, 3, 1, 2, 3, 4, 5, 1, 2, 3)\n", "16\n" ] } ], "source": [ "a = tuple() # создание пустого кортежа\n", "a = () # создание пустого кортежа\n", "c = tuple([1, 2, 3, 4, 5])\n", "с = 1, 2, 3, 4, 5 # Это тоже кортеж\n", "print(c)\n", "c += (1, 2, 3)\n", "print(c)\n", "c = c * 2\n", "print(c)\n", "print(len(c)) # длина кортежа" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Другим важным свойсвтом кортежа, явлется возможность использовать его для упаковки/распаковки данных." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "a, b = 1, 2 # 1,2 это на самом деле кортеж, который можно распаковать по отдельным переменным\n", "a, b = b, a # меняем значения переменных местами" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def fun(a,b):\n", " \"\"\"\n", " Так же кортеж можно использовать\n", " что бы вернуть из функции несколько аргументов\n", " \"\"\"\n", " a = 1\n", " b = 2\n", " return a, b\n", "\n", "c = (1,2)\n", "a, b = fun(*c) # `*c` позволяет распаковать значения из кортежа `с` как аргументы функции" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Словари\n", "\n", "Словари (они же карты (map), ассоциативные массивы и хэш-таблицы) --- структра, позволяющая организовтаь доступ к данным по ключу. Данные в словаре хранятся в формате ключ – значение. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'a': 1, 'b': 2}\n", "{'a': 3, 'b': 2}\n", "dict_keys(['a', 'b'])\n" ] } ], "source": [ "d = {'a': 1, 'b': 2}\n", "print(d)\n", "d['a'] = 3\n", "print(d)\n", "print(d.keys())" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 2)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def fun(a=1,b=2):\n", " \"\"\"\n", " Так же кортеж можно использовать\n", " что бы вернуть из функции несколько аргументов\n", " \"\"\"\n", " return a, b\n", "\n", "fun(**d) # `**d` позволяет распаковать значения из словаря `d` как именнованые аргументы функции" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "** Больше полезных модулей, типов, структур данных, методов, свойств можно найти в интернете. Гуглите!**\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python [default]", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.7" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": false, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": false, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }