N06 Data types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# N6 Типы данных\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",
    "\n",
    "1. Типы данных;\n",
    "\n",
    "2. Переменные;\n",
    "    + правила имен переменных;\n",
    "    + встроенные функции или идентификаторы.\n",
    "    \n",
    "3. Инициализация разных типов данных\n",
    "    + числа;\n",
    "    + строки;\n",
    "    + булевы переменные;\n",
    "    + последовательности и отображения.\n",
    "\n",
    "### Цель: \n",
    "\n",
    "+ представить доступные операции для стандартных типов данных;\n",
    "\n",
    "+ показать особенности синтаксиса в python при выполнении математических операций.\n",
    "\n",
    "## Типы данных \n",
    "\n",
    "Тип данных - это характеристика некоторого объекта, позволяющая определить его возможности взаимодействия с другими объектами. Обычно типов данных в языке немного, ведь типы являются кирпичиками, из которых конструируется код. Необходим баланс между действительно базовыми и полезными для решения каких-либо задач типами данных.\n",
    "\n",
    "Типичные примеры типов данных в процедурном программировании являются:\n",
    "\n",
    "+ числа (целые, действительные, комплексные);\n",
    "\n",
    "+ символы (строки);\n",
    "\n",
    "+ булевы выражения или переменные (Истина/Ложь);\n",
    "\n",
    "Более сложные типы данных, такие как последовательности, также могут иметь свой тип данных. Набор типов данных зависит от конкретного языка программирования.\n",
    "\n",
    "В python все \"определённые\" типы данных являются классами. Соответственно, ничто не мешает, используя классы, создать свой тип данных. Однако это требуется не так часто, тем более, что создать действительно удобный и полезный новый тип данных сложно.\n",
    "В большинстве случаев, особенно при обучении основам языка, встроенных типов данных более чем достаточно.\n",
    "\n",
    "Вот неполный список типов данных python:\n",
    "\n",
    "+ **число**:\n",
    "    + целые - **int**;\n",
    "    + действительные - **float**;\n",
    "    + комплексные - **complex**.\n",
    "+ **строка**:\n",
    "    + обычная строка и r-строка (raw string) - **str**;\n",
    "    + unicode строка - **unicode**;\n",
    "+ **булевы переменные** - **bool**;\n",
    "+ **последовательность**:\n",
    "    + упорядоченная:\n",
    "        + список - **list**;\n",
    "        + кортеж - **tuple**;\n",
    "    + неупорядоченная:\n",
    "        + множество - **set**.\n",
    "+ **отображение**:\n",
    "    + словарь - **dict**;\n",
    "+ **функция** - **function**;\n",
    "+ **файл** - **file**.\n",
    "\n",
    "Узнать тип данных объекта можно с помощью встроенной функции **type()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n",
      "<type 'float'>\n",
      "<type 'complex'>\n",
      "<type 'str'>\n",
      "<type 'str'>\n",
      "<type 'unicode'>\n",
      "<type 'bool'>\n",
      "----------------------\n",
      "<type 'list'>\n",
      "<type 'tuple'>\n",
      "<type 'dict'>\n",
      "<type 'set'>\n",
      "<type 'function'>\n",
      "<type 'file'>\n"
     ]
    }
   ],
   "source": [
    "# Числа\n",
    "x = 123 # целое\n",
    "print type(x)\n",
    "x = -20.5 # действительное\n",
    "print type(x)\n",
    "x = complex(1, 2) # комплексное или 1 + 2j\n",
    "print type(x)\n",
    "# Строки\n",
    "s = 'C://users' # строка\n",
    "print type(s)\n",
    "s = r'C://users' # r-строка\n",
    "print type(s)\n",
    "s = u'C://users' # юникод-строка\n",
    "print type(s)\n",
    "# Булевые переменные\n",
    "b = True # булева переменная (Истина)\n",
    "print type(b)\n",
    "print '----------------------'\n",
    "# Последовательности\n",
    "y = [1, -1, 1, -1, 1, -1] # список \n",
    "print type(y)\n",
    "y = (1, 0, 1, -1, 0, -1,) # кортеж\n",
    "print type(y)\n",
    "d = {'one' : 1, 'two' : 2, 'zero' : 0} # словарь\n",
    "print type(d)\n",
    "C = set(y) # множество\n",
    "print type(C)\n",
    "# Функции\n",
    "def abc(): # функция\n",
    "    pass\n",
    "print type(abc)\n",
    "\n",
    "# Файлы\n",
    "f = open('./pics/test.txt', 'r') # файл\n",
    "print type(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Переменные\n",
    "\n",
    "### Переменные и их имена\n",
    "\n",
    "Основная работа при кодировании алгоритма - это создание различных переменных и отношений между ними (конструкции-контейнеры в виде ветвления, циклов, функций и др.). В python в переменных хранятся не сами данные (числа, строки, булевы выражения и др.), а ссылка на них. Это очень важно сразу усвоить! Переменная в python похожа на ярлык на коробке, но не является коробкой. Ярлык должен быть понятен читающему его человеку. Поэтому в больших программах не стоит использовать такие имена переменных как **a122** или \"gf34\" и т.д. \n",
    "\n",
    "**Переменная** - это имя, состоящее из букв, символов и цифр. Однако существуют ограничения как на состав имени, так и на порядок символов в имени.\n",
    "\n",
    "### Ключевые слова. Keywords\n",
    "\n",
    "Именем переменной не может быть ключевое слово. Вот список **зарезервированных ключевых слов**.\n",
    "\t\n",
    "> and , as , assert , break , class , continue , def , del , elif , else , except , exec , finally , for , from , global , if , import , in , is , lambda , not , or , pass , print , raise , return , try , while , with , yield\n",
    "\n",
    "[Список и краткое описания](https://pythonworld.ru/osnovy/klyuchevye-slova-modul-keyword.html) ключевых слов на портале Pythonworld.ru"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']\n",
      "and\n",
      "as\n",
      "assert\n",
      "break\n",
      "class\n",
      "continue\n",
      "def\n",
      "del\n",
      "elif\n",
      "else\n",
      "except\n",
      "exec\n",
      "finally\n",
      "for\n",
      "from\n",
      "global\n",
      "if\n",
      "import\n",
      "in\n",
      "is\n",
      "lambda\n",
      "not\n",
      "or\n",
      "pass\n",
      "print\n",
      "raise\n",
      "return\n",
      "try\n",
      "while\n",
      "with\n",
      "yield\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'str' object has no attribute 'iskeyword'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-c6337abe0c2d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'def'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[1;32mif\u001b[0m \u001b[0mkeyword\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0miskeyword\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mss\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m     \u001b[1;32mprint\u001b[0m \u001b[0mss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'is a keyword'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'str' object has no attribute 'iskeyword'"
     ]
    }
   ],
   "source": [
    "# Пример вывод ключевых слов\n",
    "\n",
    "import keyword\n",
    "  \n",
    "a = keyword.kwlist   #- список всех доступных ключевых слов.\n",
    "\n",
    "print a\n",
    "\n",
    "for i, keyword in enumerate(a):\n",
    "    print keyword\n",
    "\n",
    "ss = 'def'\n",
    "if keyword.iskeyword(ss):\n",
    "    print ss, 'is a keyword'\n",
    "else:\n",
    "    print ss, 'is NOT a keyword. All OK'\n",
    "    \n",
    "    \n",
    "# Заметили ошибку в коде? ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Встроенные функции или идентификаторы\n",
    "\n",
    "Следует избегать использования имени **встроенных идентификаторов** при объявлении переменной. К встроенным идентификаторам относятся такие функции как **len()**, **list()**, **str()**, **zip()** и другие. Это не вызовет ошибки, но может привести к неочевидным последствиям при использовании.\n",
    "\n",
    "> [Список имён встроенных функций](https://docs.python.org/2/library/functions.html#built-in-funcs) языка python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'dreload', 'enumerate', 'eval', 'execfile', 'file', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']\n"
     ]
    }
   ],
   "source": [
    "# Встроенные идентификаторы\n",
    "\n",
    "import __builtin__\n",
    "print dir(__builtin__),"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Другие важные правила при использовании переменных\n",
    "\n",
    "Нельзя начинать имя переменной с цифры, но можно с буквы или символа подчеркивания!\n",
    "\n",
    "В имени переменной недопустимы следующие символы: **+, -, *, /, %, & и др.** Допускается нижнее подчёркивание.\n",
    "\n",
    "Хотя формально можно использовать **кириллицу** для описания имени переменной, лучше этого никогда не делать и использовать только буквы латинского алфавита в верхнем или нижнем регистре."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2   # правильно\n",
    "cd_25 = 33   # правильно\n",
    "len = 7   # неправильно, хотя ошибки нет: встроенная функция len переопределена"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-3-b2c995d9cc78>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-3-b2c995d9cc78>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    for = 7   # неправильно: for - ключевое слово\u001b[0m\n\u001b[1;37m        ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for = 7   # неправильно: for - ключевое слово "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-e7c3dfdea71e>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-e7c3dfdea71e>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    1b = 49.7   # неправильно - цифра на первом месте\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "1b = 49.7   # неправильно - цифра на первом месте"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Инициализация переменных\n",
    "\n",
    "Инициализация переменной означает её добавление в некоторое пространство имён. Осуществляется инициализация с помощью операции присвоения, которая выражается знаком равно \"=\".\n",
    "\n",
    "Объявленная переменная (левая часть выражения до знака равно =) в python является ссылкой на созданный и реально существующий объект в памяти компьютера."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2\n",
    "b12 = [1, 2, 3, 4]\n",
    "c_f = (True, False)\n",
    "ded = {1:-1, 2:-2, 3:-3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Приведённый выше пример показывает, что в памяти было размещено 4 объекта и для каждого есть своя ссылка-ярлык в виде имён переменных. Можно добавить ешё несколько переменных, которые будут привязаны всё к тем же объектам, то есть на некоторые объекты (числа, списки, кортежи, словари) будет несколько ссылок."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "{'zero': 0, 'two': 2, 'one': 1}\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "После присвоения переменные e и a ссылаются на один объект - число 2, а переменные f и d - на словарь.\n",
    "'''\n",
    "\n",
    "e = a\n",
    "print(e)\n",
    "f = d\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если в какой-то момент все переменные, которые ссылаются на один объект, будут удалены, то сам объект будет удалён из памяти. Удалить переменную можно с помощью функции **del()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.98754\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-28e5dd5ad73f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# удаляем переменную a\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "a = 12.98754\n",
    "print(a)\n",
    "del(a)   # удаляем переменную a\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Инициализация разных типов данных\n",
    "\n",
    "### Числа\n",
    "\n",
    "Целые числа задаются набором цифр без пробелов.\n",
    "\n",
    "Вещественные или действительные числа могут задаваться по-разному (см. пример). Разделителем целой и дробной части является точка. Отрицательные числа задаются с помощью унарного минуса(минуса перед цифрой). Для положительных чисел унарный плюс не требуется.\n",
    "   \n",
    "Комплексные числа задаются с помощью функции **complex()**, где в качестве аргументов передаются действительная и мнимая части соответственно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "312\n",
      "5.61\n",
      "-178.5465\n",
      "-2000.0\n",
      "0.015\n",
      "(2.3+5j)\n"
     ]
    }
   ],
   "source": [
    "k = 5   # целое число\n",
    "i = 312   # целое число\n",
    "a = 5.61   # действительное число\n",
    "r = -178.5465   # отрицательное действительное число\n",
    "u = -2e3   # компактная форма записи вещественного числа\n",
    "p = 1.5e-2   # компактная форма записи вещественного числа\n",
    "c = 2.3+5j   # комплексное число\n",
    "\n",
    "print(k)\n",
    "print(i)\n",
    "print(a)\n",
    "print(r)\n",
    "print(u)\n",
    "print(p)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Строки\n",
    "\n",
    "Строки задаются в кавычках (одиночных или двойных; в паре кавычки должны быть одного вида). Внутри строк может находиться всё что угодно. Пробелы также считаются, наравне с другими, за символом.\n",
    "\n",
    "Строки бывают простые, r-строки или \"сырые\" строки, а также юникодовские строки. Объявляются они одинаково, но перед открывающей кавычкой для r-строки (она же неформатированная строка) ставится буквы r, а перед юникод-строкой - буква u соответственно.\n",
    "\n",
    "О различиях между типами строк см. соответствующую тему. Кратко:\n",
    "\n",
    "+ неформатированная строка представляет символы так, как они есть. Это важно при анализе входящих строк, так как в python некоторые символы в обычных строках (слэш, например) будут восприниматься как служебные с другим значением;\n",
    "\n",
    "+ юникод-строка поддерживает [Unicode](https://ru.wikipedia.org/wiki/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4), что позволяет пользоваться не только латинским алфавитом, но и, например, кириллицей (русским языком).\n",
    "\n",
    "Чтобы создать пустую строку нужно просто поставить кавычки без пробелов внутри."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<type 'str'>, 'abc')\n",
      "(<type 'str'>, 'abc')\n",
      "(<type 'str'>, '\\xd0\\xb0\\xd0\\xb1\\xd0\\xb2')\n",
      "(<type 'unicode'>, u'\\u0430\\u0431\\u0432')\n",
      "абв\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "u'\\u0430\\u0431\\u0432'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'abc'   # простая строка\n",
    "print(type(s), s)\n",
    "r = r'abc'   # r-строка или неформатированная строка\n",
    "print(type(r), r)\n",
    "u1 = 'абв'   # кириллица в обычной строке\n",
    "print(type(u1), u1)\n",
    "u2 = u'абв'   # кириллица в юникод-строке\n",
    "print(type(u2), u2)\n",
    "\n",
    "empty_s = ''   # пустая строка. Её не видно в консоли\n",
    "\n",
    "print(u2)   # вывод на экран с помощью функции print()\n",
    "u2   # неявный вывод на экран. Сравни с print-выводом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Булевы переменные\n",
    "\n",
    "Булевы переменные могут принимать всего два значения: Истина (True) и Ложь (False). Обратите внимание на регистр заглавной буквы, это важно! Также булевым значениям не требуется кавычек, что отличает их от аналогичных строк."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<type 'bool'>, True)\n",
      "(<type 'bool'>, False)\n",
      "(<type 'str'>, 'True')\n"
     ]
    }
   ],
   "source": [
    "b = True\n",
    "f = False\n",
    "s = 'True'\n",
    "\n",
    "print(type(b), b)\n",
    "print(type(f), f)\n",
    "print(type(s), s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Последовательности и отображения\n",
    "\n",
    "Одним из самых важных элементов языка python являются последовательности. Последовательности представляют собой наборы данных различного типа (много чисел, символов, строк, перечисленных через запятую).  \n",
    "\n",
    "Последовательности могут быть как упорядоченными (списки или кортежи), так и неупорядоченными (словари, множества).\n",
    "\n",
    "Списки, кортежи и словари задаются как с помощью разных скобок:\n",
    "\n",
    "+ список - [];\n",
    "\n",
    "+ кортеж - ();\n",
    "\n",
    "+ словарь - {}.\n",
    "\n",
    "Внутри списка и кортежа элементы перечисляются через запятую. В словаре через запятую указываются связки **\"ключ\":\"значение\"** (обязательно использование двоеточия). \n",
    "\n",
    "Ключи (левая часть после двоеточия) должны быть уникальными, иначе такому ключу будет присвоено последнее переданнок значение и часть данных будет потеряна. Значения (правая часть после двоеточия) могут совпадать у разных ключей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<type 'list'>, [-100, 200, 24.7, 58.1378, 0.0, -124.12])\n",
      "(<type 'tuple'>, (-100, 200, 24.7, 58.1378, 0.0, -124.12))\n",
      "(<type 'dict'>, {True: 'False', 3: 'three', 'two': 3, 'one': 2})\n"
     ]
    }
   ],
   "source": [
    "a = [-100, 200, 24.7, 58.1378, 0.0, -124.12]   # список\n",
    "t = (-100, 200, 24.7, 58.1378, 0.0, -124.12,)   # кортеж\n",
    "d = {'one':2, 'two':3, 3:'three', True:'False'}   # словарь\n",
    "\n",
    "print(type(a), a)\n",
    "print(type(t), t)\n",
    "print(type(d), d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'three': 3, 'two': 3, 'one': 2}\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "d = {'one':2, 'two':3, 'three':True, 'three':'False', 'three':3}   # Warning! Ключи дублируются\n",
    "print(d)\n",
    "print(d['three'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### О запятой после цифр\n",
    "Обратите внимание на запятую в конце кортежа. Она необязательна, но именно она делает кортеж кортежем. Так для кортежа можно опустить скобки. Чтобы создать список нужно поставить квадратные скобки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<type 'tuple'>, (1, 2, 3, 4))\n",
      "(<type 'tuple'>, (1, 2, 3, 4))\n",
      "(<type 'list'>, [1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "a = 1, 2, 3, 4,\n",
    "print(type(a), a)\n",
    "b = 1, 2, 3, 4\n",
    "print(type(b), b)\n",
    "b = [1, 2, 3, 4,]\n",
    "print(type(b), b)"
   ]
  }
 ],
 "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
}