python_pd/02_syntax/05_dtyping.ipynb

{
 "metadata": {
  "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.8.0-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "5be696dc-7900-45eb-ba9e-444d8f184671",
   "display_name": "'Python Interactive'"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Типизация в Python\n",
    "\n",
    "## Динамическая типизация\n",
    "\n",
    "Python $-$ это язык программирования с динамической типизацией. Это означает, что переменная в разные моменты времени исполнения или в разных местах программы может быть связана с объектами разных типов. Противоположностью динамической типизации служит статическая типизация. Примерами языков со статической типизацией будут C++, Go, Java.\n",
    "\n",
    "Преимущества динамической типизации заключается в отсутствии необходимости заботиться о преобразовании типов и более простой реализации программ.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(1) foo = 42 (int)\n(2) foo = 42.0 (float)\n(3) foo = False (bool)\n(4) foo = bar (str)\n"
     ]
    }
   ],
   "source": [
    "foo = 42\n",
    "print('(1) foo =', foo, '(int)')\n",
    "foo = 42.\n",
    "print('(2) foo =', foo, '(float)')\n",
    "foo = False\n",
    "print('(3) foo =', foo, '(bool)')\n",
    "foo = 'bar'\n",
    "print('(4) foo =', foo, '(str)')"
   ]
  },
  {
   "source": [
    "## Сильная типизация\n",
    "\n",
    "Python $-$ это язык с сильной динамической типизацией. Это означает, что неявного преобразования типов нет. Так, например, следующее выражение вызовет ошибку."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-fde2ff6f6df0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'0'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "1 + '0'"
   ]
  },
  {
   "source": [
    "Здесь не стоит ожидать автоматического преобразования ```1``` в строку или ```'0'``` в число. Необходимые преобразования типов нужно совершать явно с использованием соответствующих функций.\n",
    "\n",
    "Примерами языков со слабой типизацией является JavaScript."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "10\n1\n"
     ]
    }
   ],
   "source": [
    "print(str(1) + '0')  # '10'\n",
    "print(1 + int('0'))  # 1"
   ]
  },
  {
   "source": [
    "## Проверка типов\n",
    "\n",
    "В стандартной библиотеке Python есть функция ```type(obj)```, с помощью которой можно узнать тип объекта."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "type(1) ->  <class 'int'>\ntype(\"abc\") ->  <class 'str'>\ntype(None) ->  <class 'NoneType'>\ntype(print) ->  <class 'builtin_function_or_method'>\n"
     ]
    }
   ],
   "source": [
    "print('type(1) -> ', type(1))\n",
    "print('type(\"abc\") -> ', type(\"abc\"))\n",
    "print('type(None) -> ', type(None))\n",
    "print('type(print) -> ', type(print))"
   ]
  },
  {
   "source": [
    "Проверить тип объекта можно с помощью оператора сравнения ```==``` или тождественности: ```is```, ```is not```. Тем не менее использование функции ```type``` и этих операторов не является правильным способом проверки типа объекта. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1 is int (1) -> True\n1 is int (2) -> True\n"
     ]
    }
   ],
   "source": [
    "print('1 is int (1) ->', type(1) == int)  # Совсем не рекомендуется\n",
    "print('1 is int (2) ->', type(1) is int)  # Не рекомендуется"
   ]
  },
  {
   "source": [
    "Для проверки типа объекта существует специальная функция ```isinstance```. Она принимает два аргумента. Первым аргументом должен быть проверяемый объект, а вторым тип объекта. В качестве предполагаемых типов можно указать несколько значений, тогда они указываются в скобках. В этом случае ```isinstance``` проверяет является ли тип объект одним из предполагаемых."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1 is int -> True\n1 is int or float -> True\n"
     ]
    }
   ],
   "source": [
    "print('1 is int ->', isinstance(1, int))\n",
    "print('1 is int or float ->', isinstance(1, (int, float)))"
   ]
  },
  {
   "source": [
    "Из всех типов выделяется проверка на ```None```. Если необходимо узнать, находится ли в переменной это значение, то нужно использовать ```is```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "== -> True\nis -> True\n"
     ]
    }
   ],
   "source": [
    "foo = None\n",
    "print('== ->', foo == None)  # Не по питоновски\n",
    "print('is ->', foo is None)  # Правильно"
   ]
  }
 ]
}