120_pandas(Series).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Работа над элементами объекта Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Импортировать модули\n",
    "\n",
    "import sys\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.23.4\n",
      "1.15.4\n",
      "{'system': {'commit': None, 'python': '3.6.7.final.0', 'python-bits': 64, 'OS': 'Linux', 'OS-release': '4.15.0-45-generic', 'machine': 'x86_64', 'processor': 'x86_64', 'byteorder': 'little', 'LC_ALL': 'None', 'LANG': 'en_US.UTF-8', 'LOCALE': 'en_US.UTF-8'}, 'dependencies': {'pandas': '0.23.4', 'pytest': None, 'pip': '19.0.3', 'setuptools': '39.1.0', 'Cython': None, 'numpy': '1.15.4', 'scipy': '1.2.1', 'pyarrow': None, 'xarray': None, 'IPython': '7.2.0', 'sphinx': None, 'patsy': None, 'dateutil': '2.7.5', 'pytz': '2018.7', 'blosc': None, 'bottleneck': None, 'tables': None, 'numexpr': None, 'feather': None, 'matplotlib': '3.0.2', 'openpyxl': None, 'xlrd': None, 'xlwt': None, 'xlsxwriter': None, 'lxml': None, 'bs4': None, 'html5lib': None, 'sqlalchemy': None, 'pymysql': None, 'psycopg2': None, 'jinja2': '2.10', 's3fs': None, 'fastparquet': None, 'pandas_gbq': None, 'pandas_datareader': None}}\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# 1. Импортировать модуль и проверить версию\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "print(pd.__version__)\n",
    "print(np.__version__)\n",
    "print(pd.show_versions(as_json=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    a\n",
      "1    b\n",
      "2    c\n",
      "3    d\n",
      "4    e\n",
      "dtype: object\n",
      "0    0\n",
      "1    1\n",
      "2    2\n",
      "3    3\n",
      "4    4\n",
      "dtype: int32\n",
      "a    0\n",
      "b    1\n",
      "c    2\n",
      "d    3\n",
      "e    4\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 2. Создать объект pandas Series из листа, объекта NumPy, и словаря\n",
    "\n",
    "src_list = list('abcde')\n",
    "src_arr = np.arange(5)\n",
    "src_dict = dict(zip(src_list, src_arr))\n",
    "\n",
    "s1 = pd.Series(src_list)\n",
    "s2 = pd.Series(src_arr)\n",
    "s3 = pd.Series(src_dict)\n",
    "\n",
    "print(s1)\n",
    "print(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       0\n",
      "a    one\n",
      "b    two\n",
      "c  three\n"
     ]
    }
   ],
   "source": [
    "# 3. Преобразовать объект Seris в DataFrame\n",
    "\n",
    "# создаем объект Series\n",
    "s = pd.Series({'a': 'one', 'b': 'two', 'c': 'three'})\n",
    "\n",
    "# преобразование в DataFrame\n",
    "s = s.to_frame()\n",
    "\n",
    "print(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "вариант 1\n",
      "   0  1\n",
      "0  a  0\n",
      "1  b  1\n",
      "2  c  2\n",
      "3  d  3\n",
      "4  e  4\n",
      "5  f  5\n",
      "6  g  6\n",
      "7  h  7\n",
      "8  i  8\n",
      "9  j  9\n",
      "вариант 2\n",
      "  col1  col2\n",
      "0    a     0\n",
      "1    b     1\n",
      "2    c     2\n",
      "3    d     3\n",
      "4    e     4\n",
      "5    f     5\n",
      "6    g     6\n",
      "7    h     7\n",
      "8    i     8\n",
      "9    j     9\n"
     ]
    }
   ],
   "source": [
    "# 4. Как объединить несколько объектов Series в Dataframe\n",
    "\n",
    "s1 = pd.Series(list('abcdefghij'))\n",
    "s2 = pd.Series(np.arange(10))\n",
    "\n",
    "# Вариант 1\n",
    "df1 = pd.concat([s1, s2], axis=1)\n",
    "print('вариант 1')\n",
    "print(df1)\n",
    "\n",
    "# Вариант 2\n",
    "print('вариант 2')\n",
    "df2 = pd.DataFrame({'col1': s1, 'col2': s2})\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "Name: my_name, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 5. Присвоить имя индексу объекта Series\n",
    "\n",
    "s = pd.Series({'a': 1, 'b': 2, 'c': 3})\n",
    "\n",
    "s.name = 'my_name'\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1\n",
      "1    2\n",
      "2    3\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 6. Получить элементы объекта Series A, которых нет в объекте Series B\n",
    "\n",
    "s1 = pd.Series([1, 2, 3, 4, 5])\n",
    "s2 = pd.Series([4, 5, 6, 7, 8])\n",
    "\n",
    "# возвращает вместе с индексами\n",
    "ans = s1[~s1.isin(s2)]\n",
    "\n",
    "# возвразает значения\n",
    "ans2 = np.setdiff1d(s1, s2, assume_unique=False)\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1\n",
      "1    2\n",
      "2    3\n",
      "5    6\n",
      "6    7\n",
      "7    8\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 7. Получить не пересекающиеся элементы в двух объектах Series\n",
    "\n",
    "s1 = pd.Series([1, 2, 3, 4, 5])\n",
    "s2 = pd.Series([4, 5, 6, 7, 8])\n",
    "\n",
    "# возвращает вместе с индексами\n",
    "\n",
    "# получаем объединенный Series без повтороений\n",
    "s_union = pd.Series(np.union1d(s1, s2))\n",
    "# получаем пересекающиеся данные\n",
    "s_intersect = pd.Series(np.intersect1d(s1, s2))\n",
    "# отбираем все данные, кроме пересекающихся\n",
    "ans = s_union[~s_union.isin(s_intersect)]\n",
    "\n",
    "# возвразает значения\n",
    "ans2 = np.setxor1d(s1, s2, assume_unique=False)\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    25.000000\n",
      "mean      9.182460\n",
      "std       4.782765\n",
      "min       0.433599\n",
      "25%       7.188562\n",
      "50%       8.829315\n",
      "75%      12.483571\n",
      "max      17.896064\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 8. Получить от объекта Series показатели описательной статистики\n",
    "\n",
    "state = np.random.RandomState(42)\n",
    "\n",
    "s = pd.Series(state.normal(10, 5, 25))\n",
    "pkz = s.describe()\n",
    "print(pkz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    6\n",
      "e    5\n",
      "f    3\n",
      "c    3\n",
      "b    3\n",
      "h    3\n",
      "k    2\n",
      "g    2\n",
      "i    2\n",
      "d    1\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 9. Узнать частоту уникальных элементов объекта Series (гистограмма)\n",
    "\n",
    "# создаем объект Series функцией с \n",
    "\n",
    "data = 'abcdefghik'\n",
    "len_series = 30\n",
    "s = pd.Series(np.take(list(data), np.random.randint(len(data), size=len_series)))\n",
    "\n",
    "# считаем число вхождений\n",
    "ans = s.value_counts()\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3    7\n",
      "1    3\n",
      "4    2\n",
      "2    1\n",
      "dtype: int64\n",
      "0         3\n",
      "1     Other\n",
      "2         1\n",
      "3         3\n",
      "4         3\n",
      "5     Other\n",
      "6         1\n",
      "7         1\n",
      "8         3\n",
      "9     Other\n",
      "10        3\n",
      "11        3\n",
      "12        3\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 10. Заменить все элементы объекта Series на \"Other\", кроме двух наиболее часто встречающихся\n",
    "\n",
    "state = np.random.RandomState(42)\n",
    "s = pd.Series(state.randint(low=1, high=5, size=[13]))\n",
    "print(s.value_counts())\n",
    "s[~s.isin(s.value_counts().index[:2])] = 'Other'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сумма всех \"вторников\" 27.045698322722593\n",
      "\n",
      "Средние значения по месяцам:\n",
      " 2018-01-31    0.406734\n",
      "2018-02-28    0.532092\n",
      "2018-03-31    0.464133\n",
      "2018-04-30    0.413114\n",
      "2018-05-31    0.409138\n",
      "2018-06-30    0.508725\n",
      "2018-07-31    0.505535\n",
      "2018-08-31    0.516700\n",
      "2018-09-30    0.455378\n",
      "2018-10-31    0.500903\n",
      "2018-11-30    0.460415\n",
      "2018-12-31    0.585715\n",
      "Freq: M, dtype: float64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 11. Создать объект Series в индексах дата каждый день 2018 года, в значениях случайное значение\n",
    "\n",
    "# 1. Найти сумму всех вторников\n",
    "# 2. Для каждого месяца найти среднее значение\n",
    "\n",
    "dti = pd.date_range(start='2018-01-01', end='2018-12-31', freq='B') \n",
    "s = pd.Series(np.random.rand(len(dti)), index=dti)\n",
    "\n",
    "# 1\n",
    "ans1 = s[s.index.weekday == 2].sum()\n",
    "print('Сумма всех \"вторников\"', ans1)\n",
    "print()\n",
    "\n",
    "# 2\n",
    "ans2 = s.resample('M').mean()\n",
    "print('Средние значения по месяцам:\\n', ans2)\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0  1  2  3  4\n",
      "0  1  9  2  8  1\n",
      "1  4  4  4  6  9\n",
      "2  5  6  8  1  2\n",
      "3  1  8  1  8  6\n",
      "4  4  3  3  7  7\n",
      "5  2  8  4  6  5\n",
      "6  9  5  4  4  5\n"
     ]
    }
   ],
   "source": [
    "# 12. Преобразовать объект Series в DataFrame заданной формы (shape)\n",
    "\n",
    "s = pd.Series(np.random.randint(low=1, high=10, size=[35]))\n",
    "\n",
    "# преобразование в reshape\n",
    "r = (7, 5)\n",
    "\n",
    "if r[0] * r[1] != len(s):\n",
    "    sys.exit('не возможно применить reshape')\n",
    "    \n",
    "df = pd.DataFrame(s.values.reshape(r))\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 4 6]\n",
      "Int64Index([1, 3, 4, 6], dtype='int64')\n"
     ]
    }
   ],
   "source": [
    "# 13. Найти индексы объекта Series кратные 3\n",
    "\n",
    "s = pd.Series(np.random.randint(low=1, high=10, size=[7]))\n",
    "\n",
    "# вариант 1\n",
    "ans1 = np.argwhere(s % 3==0).flatten()\n",
    "print(ans1)\n",
    "\n",
    "# вариант 2\n",
    "ans2 = s[s % 3 == 0].index\n",
    "print(ans2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     a\n",
      "4     e\n",
      "8     i\n",
      "14    o\n",
      "20    u\n",
      "10    k\n",
      "dtype: object\n",
      "0     a\n",
      "4     e\n",
      "8     i\n",
      "14    o\n",
      "20    u\n",
      "10    k\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 14. Получить данные по индексам объекта Series\n",
    "\n",
    "s = pd.Series(list('abcdefghijklmnopqrstuvwxyz'))\n",
    "p = [0, 4, 8, 14, 20, 10]\n",
    "\n",
    "# вариант 1\n",
    "ans1 = s[p]\n",
    "print(ans1)\n",
    "\n",
    "# вариант 2 (take - также может использовать многоуровневые массивы)\n",
    "ans2 = s.take(p)\n",
    "print(ans2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    0\n",
      "1    1\n",
      "2    2\n",
      "3    3\n",
      "4    4\n",
      "0    a\n",
      "1    b\n",
      "2    c\n",
      "3    d\n",
      "4    e\n",
      "dtype: object\n",
      "   0  1\n",
      "0  0  a\n",
      "1  1  b\n",
      "2  2  c\n",
      "3  3  d\n",
      "4  4  e\n"
     ]
    }
   ],
   "source": [
    "# 15. Объединить два объекта Series вертикально и горизонтально\n",
    "\n",
    "s1 = pd.Series(range(5))\n",
    "s2 = pd.Series(list('abcde'))\n",
    "\n",
    "ans_vertical = s1.append(s2)\n",
    "ans_horizontal = pd.concat([s1, s2], axis=1)\n",
    "\n",
    "print(ans_vertical)\n",
    "print(ans_horizontal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 0 6 2]\n",
      "[3 0 6 2]\n",
      "[0 2 3 6]\n"
     ]
    }
   ],
   "source": [
    "# 16. Получить индексы объекта Series A, данные которых содержатся в объетке Series B\n",
    "\n",
    "s1 = pd.Series([5, 3, 2, 1, 4, 11, 13, 8, 7])\n",
    "s2 = pd.Series([1, 5, 13, 2])\n",
    "\n",
    "# вариант 1 (медленный)\n",
    "ans1 = np.asarray([np.where(i == s1)[0].tolist()[0] for i in s2])\n",
    "print(ans1)\n",
    "\n",
    "# вариант 2 (медленный)\n",
    "ans2 = np.asarray([pd.Index(s1).get_loc(i) for i in s2])\n",
    "print(ans2)\n",
    "\n",
    "# вариант 3 (быстрый)\n",
    "ans3 = np.argwhere(s1.isin(s2)).flatten()\n",
    "print(ans3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    8\n",
      "1    7\n",
      "2    4\n",
      "3    5\n",
      "4    6\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 17. Получить объект Series B, котоырй содержит элементы без повторений объекта A\n",
    "\n",
    "s = pd.Series(np.random.randint(low=1, high=10, size=[10]))\n",
    "ans = pd.Series(s.unique())\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0           Life\n",
      "1             Is\n",
      "2    Interesting\n",
      "dtype: object\n",
      "0           Life\n",
      "1             Is\n",
      "2    Interesting\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 18. Преобразовать каждый символ объекта Series в верхний регистр\n",
    "\n",
    "s = pd.Series(['life', 'is', 'interesting'])\n",
    "\n",
    "# преобразование данных Series в строку\n",
    "s = pd.Series(str(i) for i in s)\n",
    "\n",
    "# вариант 1\n",
    "ans1 = s.map(lambda x: x.title())\n",
    "print(ans1)\n",
    "\n",
    "# вариант 1\n",
    "ans2 = pd.Series(i.title() for i in s)\n",
    "print(ans2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 3 5 4 4]\n",
      "[3 3 5 4 4]\n"
     ]
    }
   ],
   "source": [
    "# 19. Рассчитать количество символов в объекте Series\n",
    "\n",
    "s = pd.Series(['one', 'two', 'three', 'four', 'five'])\n",
    "# преобразование в строковый тип\n",
    "s = pd.Series(str(i) for i in s)\n",
    "\n",
    "# вариант 1\n",
    "ans1 = np.asarray(s.map(lambda x: len(x)))\n",
    "print(ans1)\n",
    "\n",
    "# вариант 2\n",
    "ans2 = np.asarray([len(i) for i in s])\n",
    "print(ans2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    NaN\n",
      "1    4.0\n",
      "2    2.0\n",
      "3    1.0\n",
      "4    4.0\n",
      "5    3.0\n",
      "6    2.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 20. Найти разность между объектом Series и смещением объекта Series на n\n",
    "\n",
    "n = 1\n",
    "\n",
    "s = pd.Series([1, 5, 7, 8, 12, 15, 17])\n",
    "\n",
    "ans = s.diff(periods=n)\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0   2017-01-01\n",
      "1   2015-02-02\n",
      "2   2019-01-15\n",
      "dtype: datetime64[ns]\n"
     ]
    }
   ],
   "source": [
    "# 21 Преобразовать разыне форматы строк объекта Series в дату\n",
    "\n",
    "s = pd.Series(['2017/01/01', '2015-02-02', '15 Jan 2019'])\n",
    "\n",
    "# возможно нестабильное решение, необходимо корректно указать строковые значения,\n",
    "# т.к. могут быть перепутаны месяц и день\n",
    "ans = pd.to_datetime(s)\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0   2019-02-14\n",
      "1   2019-01-22\n",
      "2   2019-03-01\n",
      "dtype: datetime64[ns]\n"
     ]
    }
   ],
   "source": [
    "# 21.1 Поскольку работа с датой часто встречается в работе, то см. еще один пример\n",
    "\n",
    "# все данные должны иметь одинаковый формат (часто бывает выгрузка из SQL)\n",
    "s = pd.Series(['14.02.2019', '22.01.2019', '01.03.2019'])\n",
    "\n",
    "# преобразование в дату\n",
    "ans = pd.to_datetime(s, format='%d.%m.%Y')\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    2018\n",
      "1    2011\n",
      "2    2012\n",
      "3    2013\n",
      "4    2018\n",
      "dtype: int64\n",
      "0     1\n",
      "1     2\n",
      "2     3\n",
      "3     4\n",
      "4    12\n",
      "dtype: int64\n",
      "0     1\n",
      "1     2\n",
      "2     3\n",
      "3     4\n",
      "4    31\n",
      "dtype: int64\n",
      "0     1\n",
      "1     5\n",
      "2     9\n",
      "3    14\n",
      "4     1\n",
      "dtype: int64\n",
      "0      1\n",
      "1     33\n",
      "2     63\n",
      "3     94\n",
      "4    365\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 22. Получить год, месяц, день, день недели, номер дня в году от объекта Series (string)\n",
    "\n",
    "from dateutil.parser import parse\n",
    "\n",
    "s = pd.Series(['01 Jan 2018', '02-02-2011', '20120303', '2013/04/04', '2018-12-31'])\n",
    "\n",
    "# парсим в дату и время\n",
    "s_ts = s.map(lambda x: parse(x, yearfirst=True))\n",
    "\n",
    "# получаем года\n",
    "print(s_ts.dt.year)\n",
    "\n",
    "# получаем месяца\n",
    "print(s_ts.dt.month)\n",
    "\n",
    "# получаем дни\n",
    "print(s_ts.dt.day)\n",
    "\n",
    "# получаем номер недели\n",
    "print(s_ts.dt.weekofyear)\n",
    "\n",
    "# получаем номер дня в году\n",
    "print(s_ts.dt.dayofyear)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0   2010-01-04\n",
      "1   2011-02-04\n",
      "2   2012-03-04\n",
      "dtype: datetime64[ns]\n"
     ]
    }
   ],
   "source": [
    "# 23. Преобразовать даты месяца и года к 7-ому дню\n",
    "\n",
    "from dateutil.parser import parse\n",
    "\n",
    "s = pd.Series(['Jan 2010', 'Feb 2011', 'Mar 2012'])\n",
    "\n",
    "ans = s.map(lambda x: parse('04 ' + x))\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0      Яблоко\n",
      "1      Orange\n",
      "4    Апельсин\n",
      "6    Reliance\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 24. Отобрать элементы объекта Series, кторые содержат не менее двух гласных\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "s = pd.Series(['Яблоко', 'Orange', 'Plan', 'Python', 'Апельсин', 'Стол', 'Reliance'])\n",
    "mask = s.map(lambda x: sum([Counter(x.lower()).get(i, 0) for i in list('aeiouаоиеёэыуюя')]) >= 2)\n",
    "ans = s[mask]\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1    test@mail.ru\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 25. Отобрать e-маилы из объекта Series\n",
    "\n",
    "# модуль для работы с регулярными выражениями\n",
    "import re\n",
    "\n",
    "emails = pd.Series(['test text @test.com', 'test@mail.ru', 'test.2ru', 'test@pp'])\n",
    "pattern = '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Za-z]{2,4}'\n",
    "mask = emails.map(lambda x: bool(re.match(pattern, x)))\n",
    "ans = emails[mask]\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bird     2.5\n",
      "cat      4.5\n",
      "dog      9.5\n",
      "horse    5.5\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 26. Получить среднее значение каждого уникального объекта Series s1 через \"маску\" другого объекта Series s2\n",
    "\n",
    "n = 10\n",
    "s1 = pd.Series(np.random.choice(['dog', 'cat', 'horse', 'bird'], n))\n",
    "s2 = pd.Series(np.linspace(1,n,n))\n",
    "ans = s2.groupby(s1).mean()\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "# 27. Найти евклидово расстоняие между двумя объектами Series\n",
    "\n",
    "n = 3\n",
    "\n",
    "s1 = pd.Series(np.random.randint(low=1, high=10, size=[n]))\n",
    "s2 = pd.Series(np.random.randint(low=1, high=10, size=[n]))\n",
    "\n",
    "ans = np.linalg.norm(s1-s2)\n",
    "ans2 = sum((s1-s2)**2)**0.5\n",
    "print(ans)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 6 9]\n"
     ]
    }
   ],
   "source": [
    "# 28. Найти индексы локальных максимумов в объекте Series\n",
    "\n",
    "s = pd.Series([1, 5, 7, 11, 8, 4, 12, 5, 8, 16, 8])\n",
    "dd = np.diff(np.sign(np.diff(s)))\n",
    "ans = np.where(dd == -2)[0] + 1\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bnbnbernkekbndare'"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 29. Заменить пробелы наименее часто встречающимся символом\n",
    "\n",
    "str_test = 'bnb ber kekb dare'\n",
    "\n",
    "s = pd.Series(list(str_test))\n",
    "freq = s.value_counts()\n",
    "least_freq = freq.dropna().index[-1]\n",
    "''.join(s.replace(' ', least_freq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-01-06    2\n",
      "2018-01-13    5\n",
      "2018-01-20    9\n",
      "2018-01-27    7\n",
      "2018-02-03    9\n",
      "2018-02-10    2\n",
      "2018-02-17    1\n",
      "2018-02-24    6\n",
      "2018-03-03    1\n",
      "2018-03-10    7\n",
      "Freq: W-SAT, dtype: int32\n"
     ]
    }
   ],
   "source": [
    "# 30. Создать объект Series, который содержит в индексах даты выходных дней субботы,\n",
    "# а в значениях случайные числа от 1 до 10\n",
    "\n",
    "s = pd.Series(np.random.randint(low=1,high=10,size=[10]), pd.date_range('2018-01-01', periods=10, freq='W-SAT'))\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-01-01    2.0\n",
      "2018-01-02    2.0\n",
      "2018-01-03    5.0\n",
      "2018-01-04    5.0\n",
      "2018-01-05    5.0\n",
      "2018-01-06    8.0\n",
      "2018-01-07    8.0\n",
      "2018-01-08    NaN\n",
      "Freq: D, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 31. Заполнить пропущенные даты, значением выше (заполненной даты)\n",
    "\n",
    "s = pd.Series([2, 5, 8, np.nan], index=pd.to_datetime(['2018-01-01', '2018-01-03', '2018-01-06', '2018-01-08']))\n",
    "# заполнить предыдущими значениями\n",
    "ans = s.resample('D').ffill()\n",
    "# заполнить последующими значениями\n",
    "ans2 = s.resample('D').bfill()\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 0.78, 0.76, 0.81, 0.75, 0.73, 0.6, 0.71, 0.69, 0.42, 0.62, 0.47, 0.33, 0.78, 0.45, 0.24, 0.39, -0.45, -1.0, nan]\n"
     ]
    }
   ],
   "source": [
    "# 32. Вычислить автокорреляцию объекта Series\n",
    "\n",
    "n = 20\n",
    "\n",
    "s = pd.Series(np.arange(n))\n",
    "s = s + np.random.normal(1, 3, n)\n",
    "\n",
    "autocorr = [s.autocorr(lag=i).round(2) for i in range(n)]\n",
    "\n",
    "print(autocorr)"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}