N03 Program structure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# N3 Структура программы на python \n",
    "\n",
    "Автор: Шабанов Павел Александрович\n",
    "\n",
    "Email: pa.shabanov@gmail.com\n",
    "\n",
    "URL: [Заметки по программированию в науках о Земле](http://progeoru.blogspot.ru/)\n",
    "\n",
    "Дата последнего обновления: 15.02.2017\n",
    "\n",
    "### Цель: \n",
    "\n",
    "+ изучить составные части программы на python;\n",
    "\n",
    "+ ознакомится со структурными особенностями языка python.\n",
    "\n",
    "## Программа и её структура\n",
    "\n",
    "[Программа](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%BD%D0%B0%D1%8F_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0) - это последовательность инструкций, определяющих процедуру решения конкретной задачи. В общем случае инструкции выполняются одна за одной, последовательно. Состав инструкций и их последовательность определяет пользователь-программист.\n",
    "\n",
    "С точки зрения программиста программа на конкретном языке - это [алгоритм](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC) и [структура данных](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Алгоритм отвечает на вопрос \"что?\", а структура данных - \"как?\". Освоение нового языка программирования по сути означает изучение лишь структуры данных, а алгоритмирование остаётся в стороне, являясь теоретической базой любого программиста.\n",
    "\n",
    "Алгоритм всегда можно записать в виде [блок-схемы](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D0%BA-%D1%81%D1%85%D0%B5%D0%BC%D0%B0), который не зависит от конкретного языка программирования.\n",
    "\n",
    "![caption](files/pics/L3/block_scheme.jpg \"Рисунок 1 Простейшая блок-схема\")\n",
    "\n",
    "### Стили программирования\n",
    "\n",
    "Вид кода во многом определяется используемой парадигмой программирования. Python является мультипарадигмальным языком, то есть он поддерживает несколько парадигм программирования:\n",
    "\n",
    "+ [процедурный](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%86%D0%B5%D0%B4%D1%83%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5);\n",
    "\n",
    "+ [объектно-ориентированный](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5);\n",
    "\n",
    "+ [функциональный](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5);\n",
    "\n",
    "Можно придерживаться как одного стиля, так и смешивать стили при кодировании: чётких границ и ограничений здесь нет. Наоборот, свобода в использовании разных подходов к описанию алгоритма является очень ценным преимуществом языка python. \n",
    "\n",
    "Самым распространённым является **процедурный стиль**. Он подразумевает, что последовательность команд-операторов можно собрать в более крупные, целостные единицы кода с помощью механизмов самого язык, то есть разбить программу на подпрограммы.\n",
    "\n",
    "Само название (**ОБЪЕКТНО-ОРИЕНТИРОВАННЫЙ стиль** или программирование, ООП) говорит о том, что этот стиль ориентируется на работу с некоторым объектом. Проще всего представить реальный объект и описать его некоторыми параметрами. Пример: магазин, банк, школа, спортсмен, клиент, пациент. Более абстрактный пример объекта - поле для игры в шахматы, тетрадь. В основе ООП лежит понятие класса или объекта как абстрактной программной единицы. В python их принято называть классами. В python даже типы данных (строки, числа и др.) также явлются классами.\n",
    "\n",
    "**Функциональный стиль** исходит из парадигмы, противоположной императивной. Как следует из названия, в данном стиле акцент сделан на рассмотрение функций. Так процесс вычисления здесь трактуется как вычисление значений функций в математическом понимании последних (в отличие от функций как подпрограмм в процедурном программировании). Функциональный стиль частично [поддерживаестя в python](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BD%D0%B0_Python) и выражается в хорошей поддержке рекурсии, функций высших порядков (функции могут принимать в качестве входящих параметров функции), декораторов и др.\n",
    "\n",
    "## Составные части программы на python\n",
    "\n",
    "Python-программа как файл-объект - это текстовый файл с расширением \".py\". Он может называться:\n",
    "\n",
    "+ python-программа;\n",
    "\n",
    "+ python-скрипт;\n",
    "\n",
    "+ python-модуль.\n",
    "\n",
    "Структурно можно выделить следующие составные части python-программы:\n",
    "\n",
    "+ главный модуль (обязательно);\n",
    "\n",
    "+ модуль (необязательно);\n",
    "\n",
    "+ класс (характерно для ООП стиля; необязательно);\n",
    "\n",
    "+ функция (необязательно).\n",
    "\n",
    "Существует руководящий документ для оформления кода на python (он же [pep8](http://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html)). [Кратко эти правила ](http://rukeba.com/by-the-way/pep8-korotko-i-po-russki/\n",
    ") регламентируют как именно нужно кодировать те или иные части программы.\n",
    "\n",
    "Там рекомендуется, например, осуществлять импорт модулей в начале любого модуля-программы. Стоит придерживаться следующего порядка импортирования: стандартные модули (os, time, sys и др.), сторонние модули (numpy, pandas, netcdf4 и др.), локальные или пользовательские модули (my_module, например). Лучше при этом отделять группы импорта пустой строкой.\n",
    "\n",
    "**Следование pep8 - это хороший тон и поддержка высокого уровня сопровождения кода.**\n",
    "\n",
    "### Модуль\n",
    "\n",
    "Python является [модульным языком](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D1%83%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) программирования.\n",
    "\n",
    "Python-программа всегда имеет один главный модуль. Вне зависимости от названия скрипта-файла, его внутреннее имя будет '__main__'. Помимо главного модуля, составяющего ядро программы, в программу могут входить и другие модули или просто модули. Они выполняют очень важную роль: предоставляют доступ к вложенному в них коду, расщиряют функциональность главного модуля.\n",
    "\n",
    "Все модули логически равнозначны, но только один модуль является главным и составляет \"ядро программы\".\n",
    "\n",
    "### Функция\n",
    "\n",
    "Подрограмма, как программная единица, в python реализована в виде **функции def()**. Внутри функции может располагаться последовательность команд-операторов, которая часто встречается в программе. Функции могут быть описаны как в том же файле, что и главный модуль. А могут хранится и в другом, стороннем модуле и импортироваться в главный.\n",
    "\n",
    "## Управление потоком выполнения программы\n",
    "\n",
    "Вне зависимости от способа организации кода (работа с классами, использование модулей и функций) решать практические задачи с помощью только последовательного исполнения строк кода практически невозможно. Почти всегда требуется возможность изменить ход выполения код, изменить состав выполняемых инструкций в зависимости от каких-либо условий. \n",
    "\n",
    "Для управления потоком выполняемых команд для произвольной совокупности строк кода (в том числе и внутри функций) служат особые конструкции-операторы - управляющие блоки. К блокам относятся:\n",
    "\n",
    "+ **циклы**;\n",
    "\n",
    "+ **ветвление** (логические вентили; условные операторы);\n",
    "\n",
    "+ **обработчики исключений**.\n",
    "\n",
    "Блоки ограничивают некоторый участок кода, последовательность строк кода, заключая их в себя. Блоки могут содержать внутри себя строки кода, а также другие блоки, т.е. управляющие блоки могут быть вложенными.\n",
    "\n",
    "Циклы позволяют повторять некоторый участок кода (объединение строк кода, лежащих внутри блока или тела цикла) или выполнение какого-либо оператора (в том числе и вызов функции). \n",
    "\n",
    "Ветвление же позволяет менять ход выполнения последовательности кода исходя из решений некоторого условия или ряда условий.\n",
    "\n",
    "Обработчики исключений перехватывают ошибки, возникающие по ходу выполнения программы, и позволяют работать алгоритму стабильно, предлагая различные варианты обхода возникшего затруднения.\n",
    "\n",
    "Циклы и ветвление - это базовые понятия, существующие практически во всех языках программирования.\n",
    "\n",
    "#### Анекдот про условия и циклы\n",
    "\n",
    "Жена посылает программиста в магазин: \n",
    "- Дорогой, купи, пожалуйста, палку колбасы, и если будут яйца, то купи десяток. \n",
    "Через полчаса программист возвращается с десятью палками колбасы. \n",
    "Жена: \n",
    "- Что это?! Зачем ты купил столько колбасы? \n",
    "Программист: \n",
    "- Ну так яйца-то были...\n",
    "\n",
    "Соль этого анекдота легко представить в виде следующего кода."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total programmer basket\n",
      "1 snag\n",
      "2 snag\n",
      "3 snag\n",
      "4 snag\n",
      "5 snag\n",
      "6 snag\n",
      "7 snag\n",
      "8 snag\n",
      "9 snag\n",
      "10 snag\n"
     ]
    }
   ],
   "source": [
    "# Пример-анекдот глазами мужа-программиста\n",
    "\n",
    "eggs = True   \n",
    "bag = []   # сумка покупателя-программиста\n",
    "\n",
    "for i in range(10):\n",
    "    if eggs:   # проверка на наличие в магазине яиц\n",
    "        bag.append('snag')\n",
    "\n",
    "print 'Total programmer basket'\n",
    "for i, item in enumerate(bag):\n",
    "    print i+1, item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total wife basket\n",
      "1 snag\n",
      "2 egg\n",
      "3 egg\n",
      "4 egg\n",
      "5 egg\n",
      "6 egg\n",
      "7 egg\n",
      "8 egg\n",
      "9 egg\n",
      "10 egg\n",
      "11 egg\n"
     ]
    }
   ],
   "source": [
    "# Пример-анекдот глазами жены\n",
    "\n",
    "eggs = True   \n",
    "bag = []   # сумка покупателя-программиста\n",
    "\n",
    "bag.append('snag')\n",
    "if eggs:\n",
    "    for i in range(10):\n",
    "        bag.append('egg')\n",
    "        \n",
    "print 'Total wife basket'\n",
    "for i, item in enumerate(bag):\n",
    "    print i+1, item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Практика\n",
    "\n",
    "Главный модуль - это исходное пространство, которое можно дополнить строками кода, блоками кода, оформленного в виде функций, а также кодом из других модулей.\n",
    "\n",
    "Модули импортируются с помощью функции **import**. Чтобы импортироват модуль необходимо знать его имя. В python имеются стандартные модули, которые поставляются прямо с python (т.н. \"батарейки\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\pashabanov\\Anaconda2\n",
      "c:\\Users\\pashabanov\\Google ����\\pyterm 2017\\notebooks\n",
      "2017-02-15 15:03:03.057000\n"
     ]
    }
   ],
   "source": [
    "# Некоторые стандартные модули: sys, os, time, datetime\n",
    "\n",
    "import os, sys   # импорт 3 стандартных модулей\n",
    "import datetime  \n",
    "\n",
    "print(sys.prefix)   # папка установки интерпретатора python\n",
    "\n",
    "print(os.getcwd())   # адрес текущей папки\n",
    "\n",
    "print(datetime.datetime.now())   # текущая дата и время "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Примеры описаний функций и классов. Описание или декларирование функций/классов не означает исполнения заключенных в них строк кода. Для их исполнения необходимо вызывать функцию или создать экземпляр класса."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to class!\n",
      "Hello, World!\n",
      "nt\n"
     ]
    }
   ],
   "source": [
    "import os   # импорт модуля os для работы с операционной системой\n",
    "\n",
    "def simple_function():\n",
    "    print('Hello, World!')\n",
    "\n",
    "class My_class():\n",
    "    '''\n",
    "    строка документирования. Она же комментарий к классу\n",
    "    '''\n",
    "    # Функция, принадлежащая классу, называется методом\n",
    "    def f_empty():   # метод f_empty\n",
    "        pass   # пустая команда, позволяющая существовать функции без других строк кода \n",
    "        \n",
    "    print('Welcome to class!')\n",
    "\n",
    "    simple_function()   # вызов функции из тела класса. Функция не принадлежит классу\n",
    "\n",
    "# Для исполнения кода класса, необходимо создать его экземпляр\n",
    "\n",
    "'''\n",
    "Начало главной, исполняемой части программы\n",
    "''' \n",
    "\n",
    "c = My_class()   # создание экземпляра класса. Экземпляром является переменная \"c\"\n",
    "print(os.name)   # печать в консоль имени ОС"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Приведённый выше пример также иллюстрирует структуру python-программы. Сам код - это главный модуль, в котором:\n",
    "\n",
    "1. импортирован модуль os;\n",
    "\n",
    "2. описана функция simple_function;\n",
    "\n",
    "3. описан класс My_class;\n",
    "\n",
    "4. создан экземпляр класса My_class, который вызывает функцию simple_function;\n",
    "\n",
    "5. Выводится в консоль название операционной системы с помощью модуля os\n",
    "\n",
    "## Заключение\n",
    "\n",
    "### Советы по кодированию для начинающих: \n",
    "\n",
    "+ если какой-то участок кода в неизменном виде повторяется хотя бы в двух местах программы, его следует оформлять в виде функции;\n",
    "\n",
    "+ суммирование, перебор, итерации в простом случае кодируются с помощью цикла или набора вложенных друг в друга циклов;\n",
    "\n",
    "+ если программа несложная и её размер не превышает пары сотен строк кода, то не имеет особого смысла выносить часть программы в сторонний модуль;\n",
    "\n",
    "+ соблюдай по возможности pep8!\n",
    "\n",
    "### Итоги\n",
    "\n",
    "Python поддерживает несколько парадигм программирования и реализует смешанную поддержку одноимённых стилей программирования. Базовым для изучения является процедурный стиль, основными понятиями которого являются подпрограмма или функция. Объектно-ориентированный стиль оперирует понятием класса, как абстрактного объекта, требующего описания и функционирования. Функциональный стиль реализован частично и выражается в виде поддержки рекурсии, вызова функциями функций и др. Все стили могут использоваться одновременно. Деление на стили условное и является относительной характеристикой организации кода.\n",
    "\n",
    "Программа на python состоит хотя бы из одного текстового файла с расширением \".py\" или \".pyw\", содержащего python-код. \n",
    "\n",
    "Python-код может быть структурно разбит на составляющие части - функции, то есть представлен в более генерализованном виде. В предельном случае программу можно представить в виде последовательности команд, вызывающих функции. \n",
    "\n",
    "Характер и направление исполнения команд-операторов, выражений и вызова функций можно регулировать с помощью управляющих блоков - циклов, ветвления и обработчиков исключений. \n",
    "\n",
    "Циклы позволяют повторять заключенные внутри тела цикла строки кода, а ветвление обеспечивает контроль над ходом течения программы. Обработчики исключений позволяют программе продолжить исполнение даже при возникновении ошибки.\n",
    "\n",
    "Свойство модульности позволяет логичнее и прозрачнее организовывать и хранить код, а также заметно облегчает использование программных единиц с едиными именами. Все модули могут содержать описания функций, классов (ООП) и строки кода, а также вызывать функции и содержание других модулей. При этом главным может быть только один модуль.\n",
    "\n",
    "### Новые команды и методы:\n",
    "\n",
    "+ **import** - функция импортирования.\n",
    "\n",
    "Новые модули стандартной библиотеки:\n",
    "\n",
    "+ **os** - модуль стандартной библиотеки для работы с операционной системой.\n",
    "\n",
    "*Новые понятия*:\n",
    "\n",
    "+ Программа;\n",
    "+ скрипт; \n",
    "+ модуль;\n",
    "+ подпрограмма;\n",
    "+ функция;\n",
    "+ класс;\n",
    "+ цикл;\n",
    "+ ветвление;\n",
    "+ исключения;\n",
    "+ стандарт pep8;\n",
    "+ стили программирования;\n",
    "+ процедурное программирование;\n",
    "+ объектно-ориентированное программирование (ООП);\n",
    "+ функциональное программирование."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}