N04 Python syntax features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# N4 Особенности синтаксиса в 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",
    "### План\n",
    "\n",
    "1. Чувствительность к регистру\n",
    "\n",
    "2. Правило 4 отступов \n",
    "\n",
    "3. Индексация элементов последовательностей\n",
    "    + Ноль как первый номер;\n",
    "    + обход индексов в обратную сторону;\n",
    "    + границы интервала индексов.\n",
    "    \n",
    "4. Комментарии\n",
    "    + однострочные комментарии;\n",
    "    + многострочные комментарии.\n",
    "\n",
    "## Особенности синтаксиса python\n",
    "\n",
    "Python относится к динамическим языкам программирования, что позволяет ему определять типы данных и осуществлять синтаксический анализ, а также трансляцию «на лету», на этапе выполнения программы.\n",
    "\n",
    "Синтаксис языка python прост и понятен. Он не злоупотребляет использованием символов и не требует обязательного описания типов данных для введения новых переменных и объектов. \n",
    "\n",
    "**Python чувствителен к регистру**. Так объекты Big и big являются разными объектами, а команды max() и Max() - разными командами.\n",
    "\n",
    "### Отступы. Правило 4 пробелов\n",
    "\n",
    "В python внутренняя иерархия алгоритма (ветвление, циклы, функции и др.) поддерживается благодаря отступам. **Четыре пробела** отделяют вложенный уровень от вышестоящего. \n",
    "\n",
    "Одиночные пробелы также важны. Если при наборе команд допустить хотя бы один лишний пробел в начале строки, то будет выведена ошибка (*IndentationError: unexpected indent*)\n",
    "\n",
    "Кому-то такая жёсткая организованность исходных кодов кажется неудобной, так как многие языки поддерживают другие способы организации иерархии исходного кода, например, С++ или Фортран90. \n",
    "\n",
    "В любом случае, следует помнить про **4 пробела** в python. Это особенно важно при использовании управляющих конструкций: функций, классов, циклов и ветвления.\n",
    "\n",
    "Согласно [pep8](http://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html#id3) функции и классы рекомендуется размещать в начале модуля после строк импорта сторонних модулей. Объявление функции/класса начинается с первой позиции строки и заканчивается двоеточием \":\". После двоеточия весь вложенный в конструкцию код необходимо начинать с 4 пробелов от позиции объявления конструкции. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Регистр\n",
    "\n",
    "Python чувствителен к регистру имён переменных. Так N и n есть разные имена переменных. Это касается и имён функций, модулей и классов. \n",
    "\n",
    "Например, для имён классов [по pep8](http://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html#id23) следует руководствоваться т.н. [\"стилем верблюда\"](https://ru.wikipedia.org/wiki/CamelCase) и начинать имя класса с заглавной буква.\n",
    "\n",
    "Так логическая переменная **ИСТИНА (True)** всегда пишется с большой буквы без кавычек. Вместо неё нельзя написать *true*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i= 0 : -0.25\n",
      "i= 1 : -0.438266220812\n",
      "i= 2 : 0.418575353022\n",
      "i= 3 : 0.0662886581427\n",
      "i= 4 : 0.0201620423208\n",
      "i= 5 : 0.0069728608327\n",
      "i= 6 : 0.00250985876606\n",
      "i= 7 : 0.000916058652377\n",
      "i= 8 : 0.000336026249145\n",
      "i= 9 : 0.000123486001003\n",
      "i= 10 : 4.54102378705e-05\n",
      "i= 11 : 1.67030956408e-05\n"
     ]
    }
   ],
   "source": [
    "# Примеры правила 4 отступов\n",
    "\n",
    "import math\n",
    "\n",
    "abc = 12\n",
    "for i in range(abc):   # Объявление цикла по i\n",
    "    a = 1./(math.exp(i) -5)   # тело цикла 1 строка\n",
    "    print 'i=', i, ':', a   # тело цикла 2 строка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В примере выше из-за синтаксической ошибки (неправильно написана команда) интерпретатор даже не выполнит ни создания экземпляра класса, ни вызов функции, который должен случиться раньше, чем возбуждение исключения ошибки.\n",
    "\n",
    "Для циклов и ветвления (подробнее см. соответствующую тему) принцип такой же, однако они могут иметь вложенность высокого порядка, причём в перемешку. И циклы и ветвление могут лежать как в теле функции, так и просто в модуле."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Element is positive value:', 1)\n",
      "('Element is negative:', -12.0)\n",
      "('Element is less than -10', -12.0)\n",
      "('Element is positive value:', 4)\n",
      "('Element is positive value:', False)\n",
      "('Element is positive value:', 0.0031)\n"
     ]
    }
   ],
   "source": [
    "# Циклы и ветвление в модуле\n",
    "\n",
    "a = [1, -12., 4, False, 0.0031]\n",
    "\n",
    "for i in a:   # объявление цикла for по i\n",
    "    if i < 0:  # объявление условного оператора if\n",
    "        print('Element is negative:', i)\n",
    "        if (i <= -10):\n",
    "            print('Element is less than -10', i)\n",
    "    else:\n",
    "        print('Element is positive value:', i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!= 1\n",
      "!= 1\n",
      "!= 1\n",
      "!= 1\n",
      "1\n",
      "!= 1\n",
      "!= 1\n",
      "!= 1\n",
      "--------\n",
      "!= 1\n",
      "!= 1\n",
      "1\n",
      "!= 1\n"
     ]
    }
   ],
   "source": [
    "# Циклы и ветвление в функции\n",
    "\n",
    "def sums(z):\n",
    "    for x in z:\n",
    "        if(x == 1):\n",
    "            print('1')\n",
    "        else:\n",
    "            print('!= 1')\n",
    "\n",
    "r = [-3, -2, -1, 0, 1, 2, 3, 4]\n",
    "r2 = [False, False, True, False]\n",
    "\n",
    "sums(r)\n",
    "print('--------')\n",
    "sums(r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Индексация последовательностей\n",
    "\n",
    "В python, как в C++ или MatLab(c), нумерация элементов последовательности или индексация начинается с **нуля (0)**. В других языках, например, Fortran, индексация начинается с единицы (1). Поэтому список, состоящий из 5 элементов будет иметь следующие индексы: 0, 1, 2, 3, 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Elements', [-10, 20, 24, 8, 0])\n",
      "('Indices', [0, 1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "a = [-10, 20, 24, 8, 0]   # список из 5 элементов\n",
    "print('Elements', a)\n",
    "b = []   # создание пустого списка (0 элементов)\n",
    "for i in a:   # перебор элементов списка a в цикле for \n",
    "    indx = a.index(i)   # вычисление индекса элемента i в списке a\n",
    "    b.append(indx)   # добавление элемента indx в список b\n",
    "print('Indices', b)   # список из 5 элементов-индексов списка a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Обход индексов в обратную сторону\n",
    "\n",
    "Python поддерживает индексацию последовательностей в обратную сторону, т.е. от последнего элемента к первому. Последний элемент в последовательности с индексом N также вызывается по индексу **-1**. Предпоследний с индексом N-1 - по индексу -2 и т.д.\n",
    "\n",
    "При этом индекс элемента(например, показываемый методом **index()** у списков и кортежей) остаётся положительным целым числом. Но появляется возможность обратиться к конечным элементам в более понятной форме, без вычисления длины последовательности."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Origin', [-10, 20, 24, 8, 0])\n",
      "('Reversed', [0, 8, 24, 20, -10])\n"
     ]
    }
   ],
   "source": [
    "a = [-10, 20, 24, 8, 0]   # список из 5 элементов\n",
    "print('Origin', a)\n",
    "ii = range(-1, -6, -1)   # список из 5 элементов от -1 до -6 не включая с шагом -1\n",
    "b = []   # создание пустого списка (0 элементов)\n",
    "for i in ii:   # перебор элементов списка a в цикле for \n",
    "    indx = a[i]   # присваивание элемента списка a по отрицательному индексу\n",
    "    b.append(indx)   # добавление элемента indx в список b\n",
    "print('Reversed', b)   # перевёрнутый список a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Индексацию имеют и строки. **Пробелы** являются полноценными знаками и занимают одну ячейку в списке элементов строки.\n",
    "\n",
    "Так строка 'Monthy Python' содержит 11 элементов, одни из них пробел. И обход строки можно начать как с начала (с нуля), так и с конца (с минус единицы)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String Length: 12\n",
      "+ Slice Pyth 4\n",
      "- Slice Pyth 4\n"
     ]
    }
   ],
   "source": [
    "s = 'Monty Python'   # это строка\n",
    "\n",
    "print 'String Length:', len(s)\n",
    "\n",
    "print '+ Slice', s[6:10], len(s[6:10])\n",
    "print '- Slice', s[-6:-2], len(s[-6:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![caption](files/pics/L4/rabota-so-strokami.jpg \"Рисунок 1 Прямая и обратная индексация в python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Граница выделения\n",
    "\n",
    "В приведённом выше примере о строке 'Monthy Python', чтобы выделить часть строки (или взять срез) \"Pyth\" мы указывали диапазон индексов: для положительного обхода это были индексы с 6 по 9 включительно, а при отрицательном с -3 по -6 включительно (шаг -1). Это легко видно из Рисунка 1.\n",
    "Так вот диапазон индексов в python НЕ ВКЛЮЧАЕТ последний, но включает первый. Т.е. чтобы взять и 6, и 7, и 8, и 9 элементы нужно написать [6:10]. Для обратного обхода правило такое же: чтобы взять и -6, и -5, и -4, и -3 нужно написать [-6 : -2]. Минус 6 и 6 включаются, а 10 и -2 - нет."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Комментарии\n",
    "\n",
    "Файлы исходных кодов необходимо снабжать комментариями, которые позволяют стороннему пользователю быстрее понять код и реализацию алгоритма. \n",
    "\n",
    "Комментарии можно оставлять как в начале модуля, даже до блока импорта (места, где импортируются модули), так и по ходу кода. Функции и классы особенно необходимо описывать комментариями. Для этого у них есть особая возможность - строка документирования.\n",
    "\n",
    "#### Однострочный комментарий\n",
    "\n",
    "Строки, начинающиеся с символа решётка \"#\", обозначают в python однострочный комментарий. Однострочный комментарий может начинать строку, а может располагаться в конце строки кода. Согласно [pep8](http://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html#id3), стандарту написания кода на python, в этом случае необходимо делать отступ в 3 пробела от последнего символа команды кода."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "# Однострочный комментарий - он не будет выполнен, даже если здесь будет строка python-кода\n",
    "\n",
    "print('Hello, world!')   # это комментарий в конце строки\n",
    "\n",
    "#print('Вы меня никогда не увидете в терминале!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Многострочный комментарий\n",
    "\n",
    "Для больших комментариев, которые не могут занять одну строку, существуют многострочные комментарии. Они обозначаются символами трёх кавычек (как одинарных, так и двойных) \n",
    "\n",
    "Стоит помнить, что для комментариев также применяется правило отступов. Необходимо соответствие между вложенными частями кода и расположенными в них комментариями. При описании комментариями циклов, ветвлений и функций интерпретатор выдаст ошибку, если комментарии будут расположены на в теле конструкции, в вне её. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'str'>\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Это многострочный комментарий. \n",
    "Его видит только редактор исходного кода\n",
    "'''\n",
    "\n",
    "a = ''' А это уже строка! \\ \n",
    "Обратный слэш служит символом перевода строки, если она \\\n",
    "очень длинная\n",
    "'''\n",
    "\n",
    "print(type(a))"
   ]
  }
 ],
 "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
}