{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Встроенные типы и операции в python\n",
    "Тип - множество значений и операций над ними. Мы не будем в коде указывать типы данных, хотя в последних версиях питона это стало возможно.\n",
    "Тем не менее, у типов есть названия, их можно использовать в коде для создания значений этих типов.\n",
    "## Числовые типы\n",
    "`int` - целые, `float` - вещественные, `complex` - комплексные.\n",
    "\n",
    "Литералы - это записи значений типа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1j"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# литералы int\n",
    "1\n",
    "10\n",
    "42\n",
    "-5\n",
    "# литералы float\n",
    "1.5\n",
    "1.0\n",
    "1.\n",
    "5.7121e4 # e4 = * 10^4, записано 57121\n",
    "# комплексные числа\n",
    "1 + 2J\n",
    "1 - 2j\n",
    "3j\n",
    "1j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно использовать функцию type, чтобы узнать тип выражения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1.5))\n",
    "print(type(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Операции с числовыми значениями:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n",
      "8\n",
      "105\n",
      "2.142857142857143\n",
      "2\n",
      "1\n",
      "6\n",
      "5\n",
      "42.0\n",
      "13\n",
      "81\n",
      "270481382942152609326719471080753083367793838278100277689020104911710151430673927943945601434674459097335651375483564268312519281766832427980496322329650055217977882315938008175933291885667484249510001\n",
      "2.704813829421526e+200\n"
     ]
    }
   ],
   "source": [
    "print(15 + 7)\n",
    "print(15 - 7)\n",
    "print(15 * 7)\n",
    "print(15 / 7)    # просто деление\n",
    "print(15 // 7)   # целочисленное деление\n",
    "print(15 % 7)    # остаток\n",
    "print(abs(-6))\n",
    "print(int(5.6))  # преобразование в int\n",
    "print(float(42)) # преобразование в float\n",
    "print(int(\"13\")) # можно так превращать строки в число\n",
    "print(3 ** 4)    # степень\n",
    "print(101 ** 100)  # целые числа могут быть произвольной точности!!!\n",
    "print(101. ** 100)  # а вот вещественные числа хранятся в обычной плавающей форме IEEE 754"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Логический тип bool\n",
    "У него всего два значения `True` и `False`.\n",
    "Операции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True and False)\n",
    "print(True or False)\n",
    "print(not True)\n",
    "print(True != False)  # аналогично xor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В тип `bool` можно превратить всё что угодно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(bool(0))\n",
    "print(bool(1))\n",
    "print(bool(42))\n",
    "print(bool(-42))\n",
    "print(bool(0.))\n",
    "print(bool(1.5))\n",
    "print(bool(\"\"))\n",
    "print(bool(\"abc\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При этом в False превращаются нули, пустые строки, пустые списки и т.п.\n",
    "Эта возможность часто используется в логических условиях:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n"
     ]
    }
   ],
   "source": [
    "if \"abc\":  # это True\n",
    "    print(\"abc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рекомендую избегать превращение всего подряд в bool, лучше в условиях писать логические выражения.\n",
    "## Операции сравнения\n",
    "Эти операции для двух чисел (и не только!) выдают логический результат"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 < 2)\n",
    "print(1 > 2)\n",
    "print(1 <= 2)\n",
    "print(1 >= 2)\n",
    "print(1 == 2)      # сравнение, что объекты имеют одинаковое содержимое\n",
    "print(1 != 2)\n",
    "print(1 is 2)      # сравнение, верно ли что объекты совпадают\n",
    "print(1 is not 2)  # не совпадают\n",
    "print(1 <= 2 <= 4) # проверяется, что выполняются все написаные сравнения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно комбинировать логические операции и сравнения, обратите внимание на использование (не использование) скобок:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 <= 3 and (4 >= 5 or 10 <= 128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Строки\n",
    "Тип str. строка - это последоваткльность символов. В Python 3 символы - это символы стандарта Unicode. Функция str может превратить в строку всё что угодно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'True'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Литералы строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'В таких строках можно вычислять выражения 2'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'\n",
    "\n",
    "\"abc\"   # нет разницы, какие кавычки\n",
    "\"abc\" 'xyz'   # два литерала подряд объединяются в одну строку\n",
    "#\"abc\" s - так нельзя, даже если s - это строка\n",
    "\n",
    "\"\"\" asd;fjasl;dkfj\n",
    "asdflk;ja sdl;fkj\n",
    "asdfl; askdjf l;asd\n",
    "\"\"\"            # текст в тройных кавычках можно писать в несколько строк.\n",
    "               # Переводы строк(line) сохраняются внутри строк(string)\n",
    "\n",
    "'''asdfsd\n",
    "sdfl;gjsdl;fg  \n",
    "'''            # одинарные кавычки работают так же\n",
    "\n",
    "\n",
    "f'В таких строках можно вычислять выражения {1 + 1}' # содержимое фигурных скобок вычисляется"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2 = 2'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'{1 + 1} = {3 - 1}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x = 42'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 42\n",
    "f\"x = {x}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Используйте это вместо оператора % и функции format.\n",
    "Для задачи о квадратном уравнении, можно вписать в фигурные скобки `:.2f`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pi = 3.143'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"pi = {22/7:.3f}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В литералах строк могут встречаться экранированные символы. Они начинаются на символ обратного слэша `\\`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "World!\n",
      "Hello\tworld\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\\nWorld!\")\n",
    "print(\"Hello\\tworld\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь `\\n` воспринимается как один символ перевода строки (10 в ASCII). А `\\t` символ табуляции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# при вычислении длины строки такие символы воспринимаются как один\n",
    "len(\"abc\\t\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно вставить unicode символ по его коду. Для этого используется `\\u` и\n",
    "четыре шестнадцатеричных цифры."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Это греческая буква хи: χ. Она же с помощью кода: χ\n"
     ]
    }
   ],
   "source": [
    "print(\"Это греческая буква хи: χ. Она же с помощью кода: \\u03C7\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"χ\" == \"\\u03C7\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще иногда нужны вот такие экранированные символы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "символ \\ и символ \"\n"
     ]
    }
   ],
   "source": [
    "print(\"символ \\\\ и символ \\\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Без экранирования кавычки python решит, что в этом месте закончилась строка.\n",
    "\n",
    "Итого, символ `\\` изменяет смысл следующего символа или символов.\n",
    "\n",
    "В python есть \"сырые\" строки. В них экранирование не работает. Сырые строки начинаются с буквы `r`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\n это перевод строки, а \\u03C7 это буква хи\n"
     ]
    }
   ],
   "source": [
    "print(r\"\\n это перевод строки, а \\u03C7 это буква хи\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Такие строки часто используются для записи регулярных выражений, потому что в них обычно много обратных слешей, и иначе их бы пришлось все экранировать.\n",
    "\n",
    "Форматные и сырые строки можно совмещать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\\\\\\\ \\n x = 42\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "print(rf\"\\\\\\\\ \\n x = {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С тройными кавычками сырые строки тоже совместимы."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Операции со строками"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "abcxyz1\n",
      "42 True\n",
      "42\n",
      "abcabcabc\n",
      "['слово', 'еще', 'одно', 'слово', 'и', 'еще', 'несколько', 'слов', 'на', 'другой', 'строке']\n",
      "['3', '4', '5', '6']\n",
      "слово1, слово2, слово3\n",
      "ABC\n",
      "abc\n",
      "Word Word\n",
      "Word word\n",
      "Istambul\n",
      "True\n",
      "False\n",
      "abc\n",
      "abc\n",
      "   abc\n",
      "abc###\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(len(\"abc\"))  # длина строки\n",
    "print(\"abc\" + \"xyz\" + \"1\")  # конкатенация строк\n",
    "# любое значение любого типа превращается в строку функцией str()\n",
    "print(str(42) + \" \" + str(2 == 2)) # \"42 True\"\n",
    "# есть похожая функция repr\n",
    "print(repr(42)) # Она превращает в строку, но обычно с большим количеством\n",
    "                # информации о значении, чем метод str()\n",
    "print(\"abc\" * 3) # повторение строки умножением\n",
    "print(\"\"\"слово    еще   одно слово\n",
    "и еще несколько слов на другой строке\n",
    "\"\"\".split()) # список слов (см. далее, что такое список)\n",
    "# split считает, что слова разделены пробелами, переводами строк,\n",
    "# но можно и явно указать разделитель:\n",
    "print(\"3+4+5+6\".split('+')) # разделили по плюсу\n",
    "# хотя мы еще не изучали списки, пример обратной функции, объединения слов:\n",
    "print(', '.join(['слово1', 'слово2', 'слово3'])) # получаем строку\n",
    "print(\"abc\".upper()) # к верхнему регистру\n",
    "print(\"AbC\".lower()) # к нижнему регистру\n",
    "print(\"word word\".title()) # первая заглавная, остальные строчные\n",
    "print(\"word word\".capitalize()) # первая заглавная, остальные строчные\n",
    "# в разных языках эти функции работают по-разному\n",
    "print(\"istambul\".capitalize())\n",
    "print(\"abc\".endswith(\"bc\")) # проверка, кончается на\n",
    "print(\"abc\".startswith(\"bc\")) # проверка, начинается на\n",
    "print(\"  abc  \\n\".strip()) # удалить пробелы и переводы строк из начала\n",
    "# и конца строки. Есть еще lstrip и rstrip, удаляют только слева или \n",
    "# только справа. Можно указать, какие символы удалять из начала и конца:\n",
    "print(\"+*+*+abc*+*+*+\".strip('+*'))\n",
    "print(\"abc\".rjust(6)) # добавить пробелы слева до ширины 6.\n",
    "print(\"abc\".ljust(6, '#')) # можно указать ширину и символ заполнения\n",
    "print(\"sbc\".isalpha()) # проверка, что все символы это буквы\n",
    "print(\"123\".isdigit()) # проверка, что все символы это цифры\n",
    "print(\"Abc\".islower()) # проверка, что все нижнего регистра\n",
    "print(\"Abc\".isupper()) # проверка, что все верхнего регистра"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Таких функций еще много, смотрите их по ссылке [методы строк (английский)](https://docs.python.org/3/library/stdtypes.html#string-methods) или [методы строк (русский)](https://pythoner.name/documentation/library/stdtypes#4.7).\n",
    "\n",
    "Функции можно комбинировать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"abc\".upper().startswith(\"A\")) # верно"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\"abc\".upper()` - это строка, поэтому с ней можно сделать любое из описанных выше действий."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"abc\"\n",
    "s.lower() == s or s.upper() == s"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}