11. Stackoverflow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9a76508b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import re\n",
    "from io import StringIO\n",
    "import io\n",
    "from collections import namedtuple\n",
    "from datetime import datetime,timedelta\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8db06643",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   weekstart    weekend       Spend     Daily\n",
      "0  01-Jan-18  07-Jan-18  34235.9220  4890.846\n",
      "1  08-Jan-18  14-Jan-18  37359.6048  5337.086\n",
      "2  15-Jan-18  21-Jan-18  38916.1164  5559.445\n",
      "3  22-Jan-18  28-Jan-18  36903.8628  5271.980\n",
      "Empty DataFrame\n",
      "Columns: [Date, Amount]\n",
      "Index: []\n",
      "         Date    Amount\n",
      "1  2018-01-01  4890.846\n",
      "2  2018-01-02  4890.846\n",
      "3  2018-01-03  4890.846\n",
      "4  2018-01-04  4890.846\n",
      "5  2018-01-05  4890.846\n",
      "6  2018-01-06  4890.846\n",
      "7  2018-01-07  4890.846\n",
      "8  2018-01-08  5337.086\n",
      "9  2018-01-09  5337.086\n",
      "10 2018-01-10  5337.086\n",
      "11 2018-01-11  5337.086\n",
      "12 2018-01-12  5337.086\n",
      "13 2018-01-13  5337.086\n",
      "14 2018-01-14  5337.086\n",
      "15 2018-01-15  5559.445\n",
      "16 2018-01-16  5559.445\n",
      "17 2018-01-17  5559.445\n",
      "18 2018-01-18  5559.445\n",
      "19 2018-01-19  5559.445\n",
      "20 2018-01-20  5559.445\n",
      "21 2018-01-21  5559.445\n",
      "22 2018-01-22  5271.980\n",
      "23 2018-01-23  5271.980\n",
      "24 2018-01-24  5271.980\n",
      "25 2018-01-25  5271.980\n",
      "26 2018-01-26  5271.980\n",
      "27 2018-01-27  5271.980\n",
      "28 2018-01-28  5271.980\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\DNISHI~1\\AppData\\Local\\Temp/ipykernel_16236/3259226528.py:23: FutureWarning: In a future version of pandas all arguments of DataFrame.set_index except for the argument 'keys' will be keyword-only\n",
      "  df2.set_index(pd.Index(index),'index',inplace=True)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame({\n",
    "    'weekstart':['01-Jan-18','08-Jan-18','15-Jan-18','22-Jan-18'],\n",
    "    'weekend':['07-Jan-18','14-Jan-18','21-Jan-18','28-Jan-18'],\n",
    "    'Spend':[34235.922,37359.6048,38916.1164,36903.8628],\n",
    "    'Daily':[4890.846,5337.086,5559.445,5271.98],\n",
    "})\n",
    "print(df)\n",
    "\n",
    "df2=pd.DataFrame(columns=['Date','Amount'])\n",
    "df2['Date']=pd.to_datetime(df2['Date'])\n",
    "#df2.reset_index(level=0,inplace=True)\n",
    "print(df2)\n",
    "\n",
    "for key,value in df.iterrows():\n",
    "    #print(key,value)\n",
    "    amount=value['Daily']\n",
    "    for date in pd.date_range(value['weekstart'], value['weekend']):\n",
    "        #print(date)\n",
    "        df2=df2.append({\"Date\":date,\"Amount\":amount},ignore_index=True)\n",
    "\n",
    "index=range(1,len(df2)+1) \n",
    "\n",
    "df2.set_index(pd.Index(index),'index',inplace=True)\n",
    "print(df2)\n",
    "\n",
    "plt.plot(df2['Date'],df2['Amount'])\n",
    "plt.xticks(rotation=90)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3d6231f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Category    Name  Year  Vals\n",
      "0      Car   Camry  2007   0.1\n",
      "1      Car   Camry  2007   0.5\n",
      "5    Truck  Tundra  2010   0.4\n"
     ]
    }
   ],
   "source": [
    "category = ['Car','Car','Car','Car','Truck','Truck','Truck']\n",
    "name = ['Camry','Camry','Camry','Camry','Tacoma','Tundra','Tundra']\n",
    "year = ['2007','2007','2008','2009','2010','2010','2011']\n",
    "vals = [0.1,0.5,0.2,0.9,0.8,0.4,0.9]\n",
    "df = pd.DataFrame({'Category': category,\n",
    "                   'Name': name,\n",
    "                   'Year': year,\n",
    "                   'Vals': vals})\n",
    "\n",
    "print(df.query(\"(Category=='Car' and Name=='Camry' and Year=='2007') or (Category=='Truck' and Name=='Tundra' and Year=='2010')\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "faa5666a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2015\n"
     ]
    }
   ],
   "source": [
    "txt=\"firstname lastname (1937-2015)\"\n",
    "pattern=r'(\\d{4}\\-\\d{4})+'\n",
    "\n",
    "matches=re.findall(pattern,txt)\n",
    "print(matches[0].split('-')[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cc2129e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        name abbrevation  value   Category\n",
      "0      FRUIT         FRU    100      FRUIT\n",
      "1    A.GRAPE       A.GRA     50      FRUIT\n",
      "2    A.APPLE       A.APP     50      FRUIT\n",
      "3  VEGETABLE         VEG     75  VEGETABLE\n",
      "4   A.TOMATO       A.TOM     25  VEGETABLE\n",
      "5  A.CABBAGE       A.CAB     25  VEGETABLE\n",
      "6   A.CARROT       A.CAR     25  VEGETABLE\n"
     ]
    }
   ],
   "source": [
    "data = [['FRUIT', 'FRU', 100],['A.GRAPE','A.GRA', 50],['A.APPLE','A.APP', 50],\n",
    "        ['VEGETABLE', 'VEG', 75],['A.TOMATO','A.TOM', 25],['A.CABBAGE','A.CAB', 25],['A.CARROT','A.CAR', 25]]\n",
    "df = pd.DataFrame(data, columns = ['name', 'abbrevation', 'value'])\n",
    "\n",
    "df['Category']=df['name'].apply(lambda x: x if x.isalpha() else None)\n",
    "df.ffill(inplace=True)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f636e48c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "find the floating point number\n",
      "['200.20356']\n"
     ]
    }
   ],
   "source": [
    "print(\"find the floating point number\")\n",
    "txt=\"200.20356AVAX\"\n",
    "pattern=r\"\\d+\\.*\\d*\"\n",
    "print(re.findall(pattern,txt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "04f90f39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "create a list of words and special characters\n",
      "['var', 'a', '=', '\"', 'hello', '\"', 'world', '(', 'print', '\"', '\"', 'hello', ',', '\"', '\"', 'a', ')']\n"
     ]
    }
   ],
   "source": [
    "print(\"create a list of words and special characters\")\n",
    "\n",
    "txt=\"\"\"var a = \"hello world\" \n",
    "print(\"hello\", \"a\")\"\"\"\n",
    "\n",
    "\n",
    "txt=re.sub('\\n','',txt)        \n",
    "results=[]\n",
    "buffer=[]\n",
    "for char in txt:\n",
    "    if char.isalpha()==False:\n",
    "        if char!=' ':\n",
    "            results.append(char)\n",
    "        if len(buffer)>0:\n",
    "            results.append(\"\".join(buffer))\n",
    "        buffer.clear()\n",
    "    else:\n",
    "        buffer.append(char)\n",
    "        \n",
    "print(results)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "485f4b6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "convert to the year and quarter\n",
      "     yrmo DIST_PERIOD\n",
      "0  202101      202101\n",
      "1  202102      202101\n",
      "2  202103      202101\n",
      "3  202104      202102\n",
      "4  202105      202102\n",
      "5  202106      202102\n",
      "6  202109      202103\n",
      "7  202111      202104\n"
     ]
    }
   ],
   "source": [
    "print(\"convert to the year and quarter\")\n",
    "data='''yrmo\n",
    "202101\n",
    "202102\n",
    "202103\n",
    "202104\n",
    "202105\n",
    "202106\n",
    "202109\n",
    "202111'''\n",
    "df = pd.read_csv(io.StringIO(data), sep=' \\s+', engine='python')\n",
    "month_year=pd.to_datetime(df['yrmo'],format=\"%Y%m\")\n",
    "df['DIST_PERIOD'] = month_year.dt.to_period(\"Q\").dt.strftime('%Y0%q')\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "96846d78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "find words with no space following or a single space between words\n",
      "['apple', 'orange ca', 'pear', 'banana']\n"
     ]
    }
   ],
   "source": [
    "print(\"find words with no space following or a single space between words\")\n",
    "list_of_strings = [\"apple\", \"orange ca\", \"pear  sa\", \"banana    sth\"]\n",
    "\n",
    "my_list=[]\n",
    "def find_phrase(list_of_strings):\n",
    "    for string in list_of_strings:\n",
    "        matches=re.findall(r\"(\\w+)( \\w+)*\", string)\n",
    "        if len(matches)>0:\n",
    "            my_list.append(\"\".join([matches[0][0],matches[0][1]]))\n",
    "    return my_list\n",
    "            \n",
    "print(find_phrase(list_of_strings))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "44273597",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('', 'private', '')\n",
      "('', '', 'protected')\n",
      "('public', '', '')\n"
     ]
    }
   ],
   "source": [
    "txt=\"a b c private d e f g protected h i j k public l m n o p\"\n",
    "\n",
    "pattern=r\"(public)|(private)|(protected)\"\n",
    "\n",
    "matches=re.findall(pattern,txt)\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bb4e106d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Look behind for the phrase MFG:\n",
      "look behind is not including in the grouping output\n",
      " acme\n",
      " initech\n"
     ]
    }
   ],
   "source": [
    "print(\"Look behind for the phrase MFG:\")\n",
    "print(\"look behind is not including in the grouping output\")\n",
    "txt=\"MFG: acme, something else, MFG: initech\"\n",
    "pattern=r\"(?<=MFG\\:)\\s+\\w+\"\n",
    "matches=re.findall(pattern,txt)\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "266dcd4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "words without the character e\n",
      "america <re.Match object; span=(0, 2), match='am'>\n",
      "e None\n",
      "E None\n",
      "world <re.Match object; span=(0, 5), match='world'>\n",
      "hello <re.Match object; span=(0, 1), match='h'>\n",
      "welcome <re.Match object; span=(0, 1), match='w'>\n",
      "board <re.Match object; span=(0, 5), match='board'>\n",
      "know <re.Match object; span=(0, 4), match='know'>\n"
     ]
    }
   ],
   "source": [
    "print(\"words without the character e\")\n",
    "strs = ['america','e', 'E', 'world','hello','welcome','board','know']\n",
    "pattern=\"(?:(?!e)[a-z])+\"\n",
    "for item in strs:\n",
    "    print(item,re.search(pattern,item))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "534ea855",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    user_id  cat_id  prod_id     score  pref_prod\n",
      "0     29762       9     3115  1.000000      335.0\n",
      "1     29762      58     1335  1.000000      335.0\n",
      "2    234894      58     1335  1.000000      335.0\n",
      "3    413276      43     1388  1.000000      335.0\n",
      "4    413276      58      335  1.000000      335.0\n",
      "5    413276      73       26  1.000000      335.0\n",
      "6   9280593       9      137  1.000000      335.0\n",
      "7   9280593      58     1335  1.000000      335.0\n",
      "8   9280593      74      160  1.000000      335.0\n",
      "9   4554542      66     1612  0.166667      197.0\n",
      "10  4554542      66     1406  0.166767      197.0\n",
      "11  4554542      66     2021  1.000000      197.0\n",
      "records:[{'user_id': 29762,'cat_id': 9,'prod_id': 3115,'score': 1.0,'pref_prod': 335.0,},{'user_id': 29762,'cat_id': 58,'prod_id': 1335,'score': 1.0,'pref_prod': 335.0,},{'user_id': 234894,'cat_id': 58,'prod_id': 1335,'score': 1.0,'pref_prod': 335.0,},{'user_id': 413276,'cat_id': 43,'prod_id': 1388,'score': 1.0,'pref_prod': 335.0,},{'user_id': 413276,'cat_id': 58,'prod_id': 335,'score': 1.0,'pref_prod': 335.0,},{'user_id': 413276,'cat_id': 73,'prod_id': 26,'score': 1.0,'pref_prod': 335.0,},{'user_id': 9280593,'cat_id': 9,'prod_id': 137,'score': 1.0,'pref_prod': 335.0,},{'user_id': 9280593,'cat_id': 58,'prod_id': 1335,'score': 1.0,'pref_prod': 335.0,},{'user_id': 9280593,'cat_id': 74,'prod_id': 160,'score': 1.0,'pref_prod': 335.0,},{'user_id': 4554542,'cat_id': 66,'prod_id': 1612,'score': 0.166667,'pref_prod': 197.0,},{'user_id': 4554542,'cat_id': 66,'prod_id': 1406,'score': 0.166767,'pref_prod': 197.0,},{'user_id': 4554542,'cat_id': 66,'prod_id': 2021,'score': 1.0,'pref_prod': 197.0,},]\n"
     ]
    }
   ],
   "source": [
    "print(\"convert a dataframe  to  a json structure\")\n",
    "data=\"\"\"user_id,cat_id,prod_id,score,pref_prod\n",
    "    29762,9,3115,1.000000,335.0\n",
    "    29762,58,1335,1.000000,335.0\n",
    "    234894,58,1335,1.000000,335.0\n",
    "    413276,43,1388,1.000000,335.0\n",
    "    413276,58,335,1.000000,335.0\n",
    "    413276,73,26,1.000000,335.0\n",
    "    9280593,9,137,1.000000,335.0\n",
    "    9280593,58,1335,1.000000,335.0\n",
    "    9280593,74,160,1.000000,335.0\n",
    "    4554542,66,1612,0.166667,197.0\n",
    "    4554542,66,1406,0.166767,197.0\n",
    "    4554542,66,2021,1.000000,197.0\"\"\"\n",
    "\n",
    "df = pd.read_csv(io.StringIO(data), sep=',')\n",
    "print(df)\n",
    "\n",
    "\n",
    "Record=namedtuple('Generic',['user_id','cat_id','prod_id','score','pref_prod'])\n",
    "\n",
    "def map_to_record(row):\n",
    "    return Record(row.user_id, row.cat_id, row.prod_id,row.score,row.pref_prod)\n",
    "\n",
    "my_list = list(map(map_to_record, df.itertuples()))\n",
    "\n",
    "def named_tuple_to_json(named_tuple):\n",
    "    \"\"\"\n",
    "    convert a named tuple to a json tree structure\n",
    "    \"\"\"\n",
    "    json_string=\"records:[\"\n",
    "    for record in named_tuple:\n",
    "        json_string+=\"{\"\n",
    "        json_string+=\"'user_id': {},'cat_id': {},'prod_id': {},'score': {},'pref_prod': {},\".format(\n",
    "        record.user_id,record.cat_id,record.prod_id,record.score,record.pref_prod)\n",
    "        json_string+=\"},\"\n",
    "    json_string+=\"]\"\n",
    "    return json_string\n",
    "\n",
    "# convert the list of named tuples to a json tree structure\n",
    "json_tree = named_tuple_to_json(my_list)\n",
    "print(json_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "d7a222bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Record ID    Record Name        Record Start          Record End  \\\n",
      "0          1    SMITH, JOHN 2020-10-20 08:00:00 2020-10-20 09:30:00   \n",
      "1          2    SMITH, JOHN 2020-10-20 09:20:00 2020-10-20 10:30:00   \n",
      "2          3    SMITH, JOHN 2020-10-20 10:20:00 2020-10-20 11:00:00   \n",
      "3          4  COOPER, ALLEN 2020-10-20 13:00:00 2020-10-20 14:15:00   \n",
      "4          5    PEREZ, HILL 2020-10-20 15:15:00 2020-10-20 16:00:00   \n",
      "5          6    SMITH, JOHN 2021-10-04 08:00:00 2021-10-20 09:30:00   \n",
      "6          7    SMITH, JOHN 2021-10-04 09:20:00 2021-10-20 10:30:00   \n",
      "7          8    SMITH, JOHN 2021-10-04 11:20:00 2021-10-20 12:00:00   \n",
      "8          9   SMITH, JOHN  2021-10-04 13:00:00 2021-10-20 14:15:00   \n",
      "9         10    SMITH, JOHN 2021-10-04 15:15:00 2021-10-20 16:00:00   \n",
      "\n",
      "                                             minutes  Count  \n",
      "0  [2020-10-20 08:00:00, 2020-10-20 08:01:00, 202...    1.0  \n",
      "1  [2020-10-20 09:20:00, 2020-10-20 09:21:00, 202...    2.0  \n",
      "2  [2020-10-20 10:20:00, 2020-10-20 10:21:00, 202...    3.0  \n",
      "3  [2020-10-20 13:00:00, 2020-10-20 13:01:00, 202...    1.0  \n",
      "4  [2020-10-20 15:15:00, 2020-10-20 15:16:00, 202...    1.0  \n",
      "5  [2021-10-04 08:00:00, 2021-10-04 08:01:00, 202...    1.0  \n",
      "6  [2021-10-04 09:20:00, 2021-10-04 09:21:00, 202...    2.0  \n",
      "7  [2021-10-04 11:20:00, 2021-10-04 11:21:00, 202...    3.0  \n",
      "8  [2021-10-04 13:00:00, 2021-10-04 13:01:00, 202...    1.0  \n",
      "9  [2021-10-04 15:15:00, 2021-10-04 15:16:00, 202...    1.0  \n"
     ]
    }
   ],
   "source": [
    "print(\"an count occurrence occurs when the minutes of one day overlay another for a person\")\n",
    "#1;SMITH, JOHN;10/20/20 8:00 AM;10/20/20 9:30 AM\n",
    "#2;SMITH, JOHN;10/20/20 9:20 AM;10/20/20 10:30 AM\n",
    "#3;SMITH, JOHN;10/20/20 10:20 AM;10/20/20 11:00 AM\n",
    "#4;COOPER, ALLEN;10/20/20 1:00 PM;10/20/20 2:15 PM\n",
    "#5;PEREZ, HILL;10/20/20 3:15 PM;10/20/20 4:00 PM\n",
    "#6;SMITH, JOHN;10/4/21 8:00 AM;10/20/21 9:30 AM\n",
    "#7;SMITH, JOHN;10/4/21 9:20 AM;10/20/21 10:30 AM\n",
    "#8;SMITH, JOHN;10/4/21 11:20 AM;10/20/21 12:00 PM\n",
    "#9;SMITH, JOHN ;10/4/21 1:00 PM;10/20/21 2:15 PM\n",
    "#10;SMITH, JOHN;10/4/21 3:15 PM;10/20/21 4:00 PM\n",
    "\n",
    "df = pd.read_csv(io.StringIO(\"\"\"\n",
    "Record ID;Record Name;Record Start;Record End\n",
    "1;SMITH, JOHN;10/20/20 8:00 AM;10/20/20 9:30 AM\n",
    "2;SMITH, JOHN;10/20/20 9:20 AM;10/20/20 10:30 AM\n",
    "3;SMITH, JOHN;10/20/20 10:20 AM;10/20/20 11:00 AM\n",
    "4;COOPER, ALLEN;10/20/20 1:00 PM;10/20/20 2:15 PM\n",
    "5;PEREZ, HILL;10/20/20 3:15 PM;10/20/20 4:00 PM\n",
    "6;SMITH, JOHN;10/4/21 8:00 AM;10/20/21 9:30 AM\n",
    "7;SMITH, JOHN;10/4/21 9:20 AM;10/20/21 10:30 AM\n",
    "8;SMITH, JOHN;10/4/21 11:20 AM;10/20/21 12:00 PM\n",
    "9;SMITH, JOHN ;10/4/21 1:00 PM;10/20/21 2:15 PM\n",
    "10;SMITH, JOHN;10/4/21 3:15 PM;10/20/21 4:00 PM\n",
    "\"\"\"),sep=';')\n",
    "\n",
    "df['Record Start']=pd.to_datetime(df['Record Start'])\n",
    "df['Record End']=pd.to_datetime(df['Record End'])\n",
    "\n",
    "def create_datetime(date,hour,minute,second):\n",
    "    month=date.month\n",
    "    day=date.day\n",
    "    year=date.year\n",
    "    #month = int(txt.split(\"/\")[0])\n",
    "    #day = int(txt.split(\"/\")[1])\n",
    "    #year = int(\"20\"+txt.split(\"/\")[2].split(\" \")[0])\n",
    "    # datetime(year, month, day, hour, minute, second, microsecond)\n",
    "    return datetime(year=year,month=month,day=day,hour=hour,minute=minute,second=second,microsecond=0)\n",
    "\n",
    "def get_minutes(row):\n",
    "    #start = datetime.strptime(row['Record Start'], '%m/%d/%y %H:%M %p')\n",
    "    start=row['Record Start']\n",
    "    start_end_of_day=create_datetime(row['Record Start'],23,59,59)\n",
    "   \n",
    "    #end = datetime.strptime(row['Record End'], '%m/%d/%y %H:%M %p')\n",
    "    end = row['Record End']\n",
    "    end_beginning_of_day=create_datetime(row['Record End'], 0,0,0)\n",
    "    \n",
    "    results=[start + timedelta(minutes=x) for x in range(0, round((end-start).total_seconds()//60)+1)]\n",
    "      \n",
    "    #for item in results:\n",
    "    #    print(item)\n",
    "    #sys.exit()\n",
    "    return results\n",
    "\n",
    "df['minutes'] = df.apply(get_minutes, axis=1)\n",
    "\n",
    "def intersection(lst1, lst2):\n",
    "    return list(set(lst1) & set(lst2))\n",
    "\n",
    "prev_row=None\n",
    "for index,row in df.iterrows():\n",
    "    if index==0:\n",
    "        df.loc[index,'Count']=1\n",
    "    else:\n",
    "        prev_row=df.iloc[index-1]\n",
    "        \n",
    "    if not prev_row is None:\n",
    "        if prev_row['Record Name']==row['Record Name']:\n",
    "            count=prev_row['Count']\n",
    "            lst1=row['minutes']\n",
    "            lst2=prev_row['minutes']\n",
    "            if len(intersection(lst1,lst2))>0:\n",
    "                df.loc[index,'Count']=count+1\n",
    "            else:\n",
    "                df.loc[index,'Count']=1\n",
    "        else:\n",
    "            df.loc[index,'Count']=1\n",
    "        \n",
    "#print(df[df['Count']>=3])   \n",
    "print(df[['Record ID','Record Name', 'Record Start','Record End','minutes','Count']])\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "83de4b83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 4 21\n"
     ]
    }
   ],
   "source": [
    "pattern=r'(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4}).*?'\n",
    "\n",
    "txt=\"10/4/21 8:00 AM\"\n",
    "month = txt.split(\"/\")[0]\n",
    "day = txt.split(\"/\")[1]\n",
    "year = txt.split(\"/\")[2].split(\" \")[0]\n",
    "print(month,day,year)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "6defd2ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "create dictionaries from key and value pairs\n",
      "   id                 value\n",
      "0  a1  0:0,1:10,2:0,3:0,4:7\n",
      "1  b4   0:5,1:0,2:0,3:0,4:1\n",
      "2  c5   0:0,1:3,2:2,3:0,4:0\n",
      "3  k2   0:0,1:2,2:0,3:4,4:0\n",
      "[{1, 10}, {4, 7}]\n",
      "[{1, 4}]\n",
      "[{1, 3}, {2}]\n",
      "[{1, 2}, {3, 4}]\n",
      "   id              value\n",
      "0  a1  [{1, 10}, {4, 7}]\n",
      "1  b4           [{1, 4}]\n",
      "2  c5      [{1, 3}, {2}]\n",
      "3  k2   [{1, 2}, {3, 4}]\n"
     ]
    }
   ],
   "source": [
    "print(\"create dictionaries from key and value pairs\")\n",
    "\n",
    "\n",
    "df = pd.DataFrame({\"id\":[\"a1\", \"b4\", \"c5\", \"k2\"], \n",
    "                   \"value\":[\"0:0,1:10,2:0,3:0,4:7\",\"0:5,1:0,2:0,3:0,4:1\",\"0:0,1:3,2:2,3:0,4:0\",\"0:0,1:2,2:0,3:4,4:0\"]})\n",
    "\n",
    "print(df)\n",
    "\n",
    "\n",
    "for key,row in df.iterrows():\n",
    "    results=[]\n",
    "    {results.append({int(k),int(v)}) if int(k)!=0 and int(v)!=0 else None for k,v in (x.split(':') for x in row['value'].split(','))}\n",
    "    print(results)\n",
    "    df.loc[key,'value']=results\n",
    "    \n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1b43c1ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   VIXCLS  Percent_Change   Cumulative                                 2item\n",
      "0   17.24        0.000000  1000.000000  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "1   18.19        0.055104  1055.104408  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "2   19.22        0.056625  1114.849188  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "3   20.11        0.046306  1166.473318  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "4   20.26        0.007459  1175.174014  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "5   22.20        0.095755  1287.703016  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "6   22.44        0.010811  1301.624130  AxesSubplot(0.125,0.125;0.775x0.755)\n",
      "7   20.05       -0.106506  1162.993039  AxesSubplot(0.125,0.125;0.775x0.755)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"calculate the accumulative change for 1000 dollars\")\n",
    "\n",
    "data=[17.24,18.19,19.22,20.11,20.26,22.2,22.44,20.05]\n",
    "df=pd.DataFrame({'VIXCLS':data})\n",
    "df['Percent_Change']=df['VIXCLS'].pct_change().fillna(0)\n",
    "\n",
    "amount=1000\n",
    "\n",
    "returns_plus_one=df['Percent_Change']+1\n",
    "cumulative_return = returns_plus_one.cumprod()\n",
    "\n",
    "df['Cumulative']=cumulative_return.mul(amount)\n",
    "\n",
    "df['2item']=df['Cumulative'].rolling(window=2).mean().plot()\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b02a3b46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['1-01', '1-02', '1-03', '1-04', '1-05', '1-06', '1-07', '1-08', '1-09',\n",
      "       '1-10', '1-11', '1-12', '2-01', '2-02', '2-03', '2-04', '2-05', '2-06',\n",
      "       '2-07', '2-08', '2-09', '2-10', '2-11', '2-12', '3-01', '3-02', '3-03',\n",
      "       '3-04', '3-05', '3-06', '3-07', '3-08', '3-09', '3-10', '3-11', '3-12'],\n",
      "      dtype='object', name='Month')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.read_csv('shampoo.csv',parse_dates=['Month'])\n",
    "#print(df.columns)\n",
    "pivot=df.pivot_table(index=['Month'],values=['Sales'],aggfunc=np.sum)\n",
    "print(pivot.index)\n",
    "plt.plot(pivot.index,pivot.values)\n",
    "plt.xticks(rotation=90)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7c682ec8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   id                time       time_diff\n",
      "0   2 2021-11-20 22:17:46 0 days 00:13:02\n",
      "1   2 2021-11-20 22:19:02 0 days 00:13:02\n",
      "2   2 2021-11-20 22:06:00 0 days 00:13:02\n",
      "3   4 2021-11-20 22:18:06 0 days 00:00:00\n",
      "4   4 2021-11-20 22:18:06 0 days 00:00:00\n"
     ]
    }
   ],
   "source": [
    "data = {'id': [2, 2, 2, 4, 4], 'time': ['22:17:46', '22:19:02', '22:06:00', '22:18:06', '22:18:06']}\n",
    "df=pd.DataFrame.from_dict(data)\n",
    "\n",
    "df['time'] = pd.to_datetime(df['time'])\n",
    "df['time_diff'] = df.groupby('id')['time'].transform(lambda x: x.max() - x.min())\n",
    "\n",
    "#grouped=df.groupby('id')['time'].agg(['min', 'max'])\n",
    "#for item in grouped.items():\n",
    "#    print(item['min'],item['max'])\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "52680c13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "include only rows landing on wednesday \n",
      "2020-02-05    1.164147\n",
      "2020-02-12   -0.872873\n",
      "2020-02-19   -0.572917\n",
      "2020-02-26    0.936244\n",
      "2020-03-04    0.890783\n",
      "2020-03-11   -0.911510\n",
      "2020-03-18   -0.519189\n",
      "2020-03-25   -0.392932\n",
      "2020-04-01    1.256400\n",
      "2020-04-08   -0.995776\n",
      "2020-04-15    0.480521\n",
      "2020-04-22    2.532899\n",
      "2020-04-29    0.777943\n",
      "2020-05-06   -0.079824\n",
      "2020-05-13    0.284184\n",
      "2020-05-20    0.684372\n",
      "2020-05-27   -2.227408\n",
      "2020-06-03   -1.175986\n",
      "2020-06-10    0.014088\n",
      "2020-06-17    0.397393\n",
      "2020-06-24   -0.812656\n",
      "2020-07-01   -1.120630\n",
      "2020-07-08    0.098621\n",
      "2020-07-15   -0.824770\n",
      "2020-07-22   -0.638800\n",
      "2020-07-29    0.411657\n",
      "2020-08-05   -0.540858\n",
      "2020-08-12   -0.318984\n",
      "2020-08-19   -0.476933\n",
      "2020-08-26    2.349569\n",
      "2020-09-02    1.358365\n",
      "2020-09-09   -1.291633\n",
      "2020-09-16    1.594093\n",
      "2020-09-23   -0.274841\n",
      "2020-09-30    2.289768\n",
      "2020-10-07    0.529003\n",
      "2020-10-14    0.889906\n",
      "2020-10-21    0.465075\n",
      "2020-10-28   -0.197626\n",
      "2020-11-04    1.404271\n",
      "2020-11-11    1.242519\n",
      "2020-11-18    0.038522\n",
      "2020-11-25    0.182514\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print('include only rows landing on wednesday ')\n",
    "\n",
    "days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']\n",
    "\n",
    "indices = pd.date_range(start='feb 01 2020', end='nov 30 2020', freq='D')\n",
    "sr=pd.Series(index=indices, data=np.random.randn(indices.shape[0]))\n",
    "print(sr[sr.index.dayofweek == 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6572887f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(Timestamp('2021-11-01 00:00:00'), 0), (Timestamp('2021-11-02 00:00:00'), 0), (Timestamp('2021-11-03 00:00:00'), 0), (Timestamp('2021-11-04 00:00:00'), 0), (Timestamp('2021-11-05 00:00:00'), 0)]\n"
     ]
    }
   ],
   "source": [
    "txt=\"\"\"scanned_date,total       \n",
    "2021-11-01,0\n",
    "2021-11-02,0\n",
    "2021-11-03,0\n",
    "2021-11-04,0\n",
    "2021-11-05,0\n",
    "\"\"\"\n",
    "\n",
    "#https://www.py4u.net/discuss/17020\n",
    "\n",
    "df = pd.read_csv(io.StringIO(txt),sep=',',parse_dates=['scanned_date'])\n",
    "print(list(map(lambda tuple_obj: \n",
    "               (\n",
    "                   pd.to_datetime(tuple_obj[1],'%M/%d/%Y')\n",
    "                  #str(tuple_obj[1].astype(\"datetime64[M]\").astype(int)% 12 + 1)\n",
    "                  # + \"\\\\\" + str(tuple_obj[1].astype(object).day)\n",
    "                  # + \"\\\\\" + str(tuple_obj[1].astype(\"datetime64[Y]\"))\n",
    "                 ,\n",
    "                tuple_obj[2]),\n",
    "               df.to_records())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6d7b680d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    ColA       ColB  ColC    ColD  newCol\n",
      "0      B 2021-10-24     2     NaN       0\n",
      "1      B 2021-10-25     4     2.0       0\n",
      "2      B 2021-10-26   500   496.0       0\n",
      "3      B 2021-10-27   100  -400.0       0\n",
      "4      B 2021-10-28    55   -45.0       1\n",
      "5      B 2021-10-29   600   545.0       1\n",
      "6      B 2021-10-30     8  -592.0       0\n",
      "7      B 2021-10-31  4300  4292.0       1\n",
      "8      B 2021-11-01   200 -4100.0       1\n",
      "9      H 2021-10-24   600     NaN       1\n",
      "10     H 2021-10-25     0  9400.0       1\n",
      "11     H 2021-10-26   100 -9900.0       0\n",
      "12     H 2021-10-27   300   200.0       1\n",
      "13     H 2021-10-28     2  -292.0       1\n",
      "14     H 2021-10-29     8     6.0       0\n",
      "15     H 2021-10-30   600   592.0       0\n",
      "16     H 2021-10-31   600     0.0       0\n",
      "17     H 2021-11-01   650    50.0       1\n"
     ]
    }
   ],
   "source": [
    "txt=\"\"\" ColA,ColB,ColC,ColD\n",
    "B,2021-10-24,2,NA\n",
    "B,2021-10-25,4,2\n",
    "B,2021-10-26,500,496\n",
    "B,2021-10-27,100,-400\n",
    "B,2021-10-28,55,-45\n",
    "B,2021-10-29,600,545\n",
    "B,2021-10-30,8,-592 \n",
    "B,2021-10-31,4300,4292 \n",
    "B,2021-11-01,200,-4100\n",
    "H,2021-10-24,600,NA\n",
    "H,2021-10-25,0000,9400 \n",
    "H,2021-10-26,100,-9900 \n",
    "H,2021-10-27,300,200\n",
    "H,2021-10-28,2,-292\n",
    "H,2021-10-29,8,6\n",
    "H,2021-10-30,600,592\n",
    "H,2021-10-31,600,0\n",
    "H,2021-11-01,650,50\"\"\"\n",
    "\n",
    "df = pd.read_csv(io.StringIO(txt),sep=',',parse_dates=['ColB'])\n",
    "df['ColD_2']=df['ColD'].shift(2)\n",
    "df['ColD_3']=df['ColD'].shift(3)\n",
    "df['ColD_2_check']=np.where(df['ColD_2']>200,1,0)\n",
    "df['ColD_3_check']=np.where(df['ColD_3']>200,1,0)\n",
    "df['newCol']=df['ColD_2_check']|df['ColD_3_check']\n",
    "df.drop(['ColD_2','ColD_3','ColD_2_check','ColD_3_check'],inplace=True,axis=1)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4dfca03c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "annualized return rate\n",
      "1.03\n",
      "1.07\n",
      "1.05\n",
      "1.12\n",
      "1.01\n",
      "0.05533402290765199\n",
      "1.00133335\n",
      "1.00148724\n",
      "0.001410292043902306\n",
      "1.00079676\n",
      "1.0012311\n",
      "0.0010139064424810051\n"
     ]
    }
   ],
   "source": [
    "print(\"annualized return rate\")\n",
    "data=[ 3, 7, 5, 12, 1]\n",
    "\n",
    "def annualize_rate(data):\n",
    "    retVal=0\n",
    "    accum=1\n",
    "    for item in data:\n",
    "        print(1+(item/100))\n",
    "        accum*=1+(item/100)\n",
    "        retVal=pow(accum,1/len(data))-1\n",
    "    return retVal\n",
    "    \n",
    "print(annualize_rate(data))\n",
    "\n",
    "data=[0.133335,0.148724]\n",
    "\n",
    "print(annualize_rate(data))\n",
    "\n",
    "\n",
    "data=[0.079676,0.123110]\n",
    "print(annualize_rate(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b84a6e78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Annualized  Percent_Change  Cumulative  \\\n",
      "0    0.035719        0.000000    1.000000   \n",
      "1    0.031417       -0.120440    0.879560   \n",
      "2    0.030872       -0.017347    0.864302   \n",
      "3    0.029147       -0.055876    0.816008   \n",
      "\n",
      "                                  2item  \n",
      "0  AxesSubplot(0.125,0.125;0.775x0.755)  \n",
      "1  AxesSubplot(0.125,0.125;0.775x0.755)  \n",
      "2  AxesSubplot(0.125,0.125;0.775x0.755)  \n",
      "3  AxesSubplot(0.125,0.125;0.775x0.755)  \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data=[0.035719,0.031417,0.030872,0.029147]\n",
    "df=pd.DataFrame({'Annualized':data})\n",
    "df['Percent_Change']=df['Annualized'].pct_change().fillna(0)\n",
    "\n",
    "amount=1\n",
    "\n",
    "returns_plus_one=df['Percent_Change']+1\n",
    "cumulative_return = returns_plus_one.cumprod()\n",
    "\n",
    "df['Cumulative']=cumulative_return.mul(amount)\n",
    "\n",
    "df['2item']=df['Cumulative'].rolling(window=2).mean().plot()\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6b126249",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03178875"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.035719+0.031417+0.030872+0.029147)/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "04b80364",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Player Position  Score\n",
      "6    Aaron Rodgers       QB  10.48\n",
      "0  Darrel Williams       RB  24.90\n",
      "1      Mark Ingram       RB  18.80\n",
      "5    Davante Adams       WR  11.30\n",
      "8      Corey Davis       WR   8.80\n",
      "9   T.J. Hockenson       TE   0.00\n",
      "7       Tyler Bass        K   9.00\n",
      "4    Buffalo Bills      DEF  12.00\n"
     ]
    }
   ],
   "source": [
    "txt=\"\"\"Player,Position,Score\n",
    "Darrel Williams,RB,24.9\n",
    "Mark Ingram,RB,18.8\n",
    "Michael Carter,RB,16.2\n",
    "Najee Harris,RB,15.3\n",
    "Buffalo Bills,DEF,12\n",
    "Davante Adams,WR,11.3\n",
    "Aaron Rodgers,QB,10.48\n",
    "Tyler Bass,K,9\n",
    "Corey Davis,WR,8.8\n",
    "T.J. Hockenson,TE,0\"\"\"\n",
    "\n",
    "df = pd.read_csv(io.StringIO(txt),sep=',')\n",
    "requirements_dictionary = {'QB': 1, 'RB': 2, 'WR': 2, 'TE': 1, 'K': 1, 'DEF': 1, 'FLEX': 2}\n",
    "#print(df)\n",
    "df_top_rows = pd.DataFrame()\n",
    "for position in requirements_dictionary.keys():\n",
    "    df_top_rows = df_top_rows.append(df[df['Position'] == position].sort_values(by='Score', ascending=False).head(requirements_dictionary[position]))\n",
    "#print(df_top_rows)\n",
    "\n",
    "\n",
    "position='FLEX'\n",
    "df_flex_rows = df_top_rows.append(df[df['Position'].isin(['RB','WR','TE'])].sort_values(by='Score', ascending=False).head(requirements_dictionary[position]))\n",
    "\n",
    "#print(df_flex_rows)\n",
    "df_result=pd.concat([df_top_rows,df_flex_rows],axis=0)\n",
    "df_result.drop_duplicates(inplace=True)\n",
    "print(df_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c09601c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  column_1 column_2 column_3 column_4\n",
      "0    1,2,3        1        2        3\n",
      "1    2,3,4        2        3        4\n"
     ]
    }
   ],
   "source": [
    "txt=\"\"\"\n",
    "column_1\n",
    "1,2,3\n",
    "2,3,4\n",
    "\"\"\"\n",
    "df=pd.read_csv(io.StringIO(txt),sep='\\n')\n",
    "df[['column_2','column_3','column_4']]=df['column_1'].str.split(',',expand=True)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "id": "f39ea75c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\DNISHI~1\\AppData\\Local\\Temp/ipykernel_16728/3809484238.py:40: MatplotlibDeprecationWarning: The 's' parameter of annotate() has been renamed 'text' since Matplotlib 3.3; support for the old name will be dropped two minor releases later.\n",
      "  ax.annotate(xy=[x2,y2],s=value)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x1200 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data=\"\"\"Date,Ta\n",
    "2020-01-01 00:00:00,6.242405\n",
    "2020-01-01 01:00:00,4.923052\n",
    "2020-01-01 02:00:00,5.112286\n",
    "2020-01-01 03:00:00,4.689673\n",
    "2020-01-01 04:00:00,4.493104\n",
    "2020-01-01 05:00:00,3.719512\n",
    "2020-01-01 06:00:00,5.473153\n",
    "2020-01-01 07:00:00,3.442055\n",
    "2020-01-01 08:00:00,4.045178\n",
    "2020-01-01 09:00:00,2.585951\n",
    "2020-01-01 10:00:00,4.028845\n",
    "2020-01-01 11:00:00,5.411510\n",
    "2020-01-01 12:00:00,3.383155\n",
    "2020-01-01 13:00:00,5.997180\n",
    "2020-01-01 14:00:00,6.485442\n",
    "2020-01-01 15:00:00,4.240901\n",
    "2020-01-01 16:00:00,3.637405\n",
    "2020-01-01 17:00:00,2.766216\n",
    "2020-01-01 18:00:00,6.024569\n",
    "2020-01-01 19:00:00,5.503587\n",
    "2020-01-01 20:00:00,5.532941\n",
    "2020-01-01 21:00:00,4.251602\n",
    "2020-01-01 22:00:00,4.444596\n",
    "2020-01-01 23:00:00,2.935362\n",
    "\"\"\"\n",
    "#df['Ta'].plot(figsize=(20,12),legend=True,subplots=True,ylim=(0,12),\n",
    "#              xticks=list(df.index.values),fontsize=10,grid=True,\n",
    "#              rot=0, xlim=(pd.Timestamp('2020-01-01 00:00:00'),pd.Timestamp('2020-01-01 23:00:00')))\n",
    "\n",
    "def plot_df(df, x, y, title=\"\", xlabel='Date', ylabel='Value', dpi=100):\n",
    "    fig,ax=plt.subplots(figsize=(20,12), dpi=dpi)\n",
    "    ax.plot(x, y, color='tab:red')\n",
    "    #plt.xticks(rotation=90)\n",
    "    items=range(0,len(df))\n",
    "    for index in items:\n",
    "        y2=y[index]\n",
    "        x2=x[index]\n",
    "        value=\"{:.2f}\".format(y2)\n",
    "        ax.annotate(xy=[x2,y2],s=value)\n",
    "        #\n",
    "        #if index%2==0:\n",
    "        #    y2=1\n",
    "        #else:\n",
    "        #    y2=2\n",
    "        #ax.annotate(xy=[x2,y2],s=value)\n",
    "        #ax.annotate(xy=[x2,y2],s=str(y2))\n",
    "    plt.xlim([pd.Timestamp('2020-01-01 00:00:00'),pd.Timestamp('2020-01-01 23:00:00')])        \n",
    "    plt.ylim(0,12)\n",
    "    plt.gca().set(title=title, xlabel=xlabel, ylabel=ylabel)\n",
    "    plt.show()\n",
    "\n",
    "df = pd.read_csv(StringIO(data), sep=',', index_col=0,parse_dates=['Date'])\n",
    "plot_df(df, x=df.index, y=df.Ta, title='Temparature')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c6d698ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        a  b_x  c_x   b_y   c_y\n",
      "0     red    1    1  44.0  55.0\n",
      "1   green    5    7   NaN   NaN\n",
      "2  yellow    6    8   NaN   NaN\n",
      "3    blue    7    9   NaN   NaN\n",
      "44.0\n",
      "x\n",
      "x\n",
      "x\n",
      "        a     b     c\n",
      "0     red  44.0  55.0\n",
      "1   green   5.0   7.0\n",
      "2  yellow   6.0   8.0\n",
      "3    blue   7.0   9.0\n"
     ]
    }
   ],
   "source": [
    "df4 = pd.DataFrame({'a':['red','green','yellow','blue'],'b':[1,5,6,7],'c':[1,7,8,9]})\n",
    "df5 = pd.DataFrame({'a':'red','b':44, 'c':55}, index=[0])\n",
    "\n",
    "df3 = pd.merge(df4, df5, how='left', on='a')\n",
    "print(df3)\n",
    "\n",
    "for key, row in df3.iterrows():\n",
    "    \n",
    "    if pd.isna(row['b_y'])==False:\n",
    "        print(row['b_y'])\n",
    "        df3.loc[key,'b']=row['b_y']\n",
    "        df3.loc[key,'c']=row['c_y']\n",
    "    else:\n",
    "        print('x')\n",
    "        df3.loc[key,'b']=row['b_x']\n",
    "        df3.loc[key,'c']=row['c_x']\n",
    "\n",
    "df3 = df3.drop(['b_x', 'c_x', 'b_y', 'c_y'], axis=1)\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "2f9cb10c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "multiple df1 by df2 for every row of df1\n",
      "         Date  ABC  DEF  XYZ\n",
      "0  2020-01-31  1.5  1.6  0.6\n",
      "1  2020-02-31  0.5  1.2  1.5\n",
      "2  2020-03-31  2.0  0.8  1.8\n",
      "3  2020-04-31  1.0  0.8  2.1\n"
     ]
    }
   ],
   "source": [
    "print(\"multiple df1 by df2 for every row of df1\")\n",
    "\n",
    "df1=\"\"\"\n",
    "Date\tABC\tDEF\tXYZ\n",
    "2020-01-31\t3\t4\t2\n",
    "2020-02-31\t1\t3\t5\n",
    "2020-03-31\t4\t2\t6\n",
    "2020-04-31\t2\t2\t7\n",
    "\"\"\"\n",
    "df2=\"\"\"\n",
    "Year\tABC\tDEF\tXYZ\n",
    "2020\t.5\t.4\t.3\n",
    "\"\"\"\n",
    "\n",
    "def create_df(df):\n",
    "    df=df.strip().split('\\n')\n",
    "    df=list(map(lambda x: x.strip().split('\\t'),df))\n",
    "    df=pd.DataFrame(df[1:],columns=df[0])\n",
    "    return df\n",
    "\n",
    "df1=create_df(df1)\n",
    "df1['ABC']=df1['ABC'].astype(float)\n",
    "df1['DEF']=df1['DEF'].astype(float)\n",
    "df1['XYZ']=df1['XYZ'].astype(float)\n",
    "df2=create_df(df2)\n",
    "df2['ABC']=df2['ABC'].astype(float)\n",
    "df2['DEF']=df2['DEF'].astype(float)\n",
    "df2['XYZ']=df2['XYZ'].astype(float)\n",
    "\n",
    "cols = ['ABC', 'DEF', 'XYZ']\n",
    "df3 = df1.copy()\n",
    "df3[cols]=df1[cols].mul(df2[cols].values)\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "id": "6c6be226",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "find all the slot values\n",
      "                         id                        grp            output\n",
      "0  Alpha-old-1_MOD (Slot01)                          -          [Slot01]\n",
      "1       Alpha-old-1_PR GRP1  MOD (Slot07);MOD (Slot08)  [Slot07, Slot08]\n",
      "2        Beta-new-1_PR GRP2  MOD (Slot13);MOD (Slot14)  [Slot13, Slot14]\n",
      "3   Beta-old-1_MOD (Slot03)                          -          [Slot03]\n"
     ]
    }
   ],
   "source": [
    "print(\"find all the slot values\")\n",
    "data=\"\"\"id\\tgrp\n",
    "Alpha-old-1_MOD (Slot01)\\t-\n",
    "Alpha-old-1_PR GRP1\\tMOD (Slot07);MOD (Slot08)\n",
    "Beta-new-1_PR GRP2\\tMOD (Slot13);MOD (Slot14)\n",
    "Beta-old-1_MOD (Slot03)\\t-\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "import re\n",
    "df=pd.read_csv(io.StringIO(data),sep='\\t')\n",
    "\n",
    "columns=df.columns\n",
    "for column in columns:\n",
    "    df[column]=df[column].astype(str)\n",
    "\n",
    "#pattern=r\"[\\s\\w\\(]+(?<=Slot){1}(\\d{2})+[\\s\\w\\)]+\"\n",
    "pattern=r\"[\\s\\w\\(]+(Slot{1}\\d{2})+[\\s\\w\\)]+\"\n",
    "\n",
    "df['output']=''\n",
    "for key,row in df.iterrows():\n",
    "    if re.search(\"PR GRP\",str(row['id'])):\n",
    "        matches=re.findall(pattern,str(row['grp']))\n",
    "    else:\n",
    "        matches=re.findall(pattern,str(row['id']))\n",
    "    if len(matches)>0:\n",
    "        df.loc[key,'output']=matches\n",
    "\n",
    "print(df[['id','grp','output']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "fe4826cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2021-01-01 05:00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2021-01-01 06:00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     0\n",
       "0  2021-01-01 05:00:00\n",
       "1  2021-01-01 06:00:00"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({\"A\": [\"2021-01-01 05:00:00Acme Industries\",\n",
    "                         \"2021-01-01 06:00:00Acme LLC\"]})\n",
    "\n",
    "df.A.str.extract(\"(\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2})?.*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "d3407c44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  col_1    sort\n",
      "0    27  27.000\n",
      "1   >27  27.001\n",
      "2  27.2  27.200\n",
      "3    28  28.000\n"
     ]
    }
   ],
   "source": [
    "col_1=['27','>27','27.2','28']\n",
    "df=pd.DataFrame({'col_1':col_1})\n",
    "\n",
    "df['sort']=df['col_1'].apply(lambda x: float(re.sub('>','',x))+0.001 if '>' in x else float(x))\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "id": "c937c3f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['714285']\n",
      "['3']\n",
      "0.5\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "def repeat(result):    \n",
    "    pattern=r\"\\d+\\.\\d+(\\d+)\\1\"\n",
    "    matches=re.findall(pattern,result)\n",
    "    return matches\n",
    "\n",
    "result=str(1/7)\n",
    "print(repeat(result))\n",
    "#(\\b\\d\\b)\\1\n",
    "result=str(1/3)\n",
    "print(repeat(result))\n",
    "result=str(1/2)\n",
    "print(result)\n",
    "print(repeat(result))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "50ba6657",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['step1'], ['step1', 'step2'], ['step1', 'step2', 'step3']]\n",
      "['step1']\n",
      "['step1', 'step2']\n",
      "['step1', 'step2', 'step3']\n",
      "['step1']\n",
      "['step1', 'step2']\n",
      "['step1', 'step2', 'step3']\n",
      "  id  sid              steps page_step1 page_step2 page_step3\n",
      "0  A    1              step1      step1       None       None\n",
      "1  A    1        step1-step2      step1      step2       None\n",
      "2  A    1  step1-step2-step3      step1      step2      step3\n"
     ]
    }
   ],
   "source": [
    "txt=\"\"\"id\\tsid\\tsteps\n",
    "A\\t1\\tstep1\n",
    "A\\t1\\tstep1-step2\n",
    "A\\t1\\tstep1-step2-step3\"\"\"\n",
    "\n",
    "df=pd.read_csv(io.StringIO(txt),sep='\\t')\n",
    "#print(df)\n",
    "results=df['steps'].apply(lambda x: x.split('-'))\n",
    "print(results.tolist())\n",
    "\n",
    "def Slice2(x):\n",
    "    print(x)\n",
    "    if len(x)>=2:\n",
    "        return x[1]\n",
    "    return None\n",
    "\n",
    "def Slice3(x):\n",
    "    print(x)\n",
    "    if len(x)>=3:\n",
    "        return x[2]\n",
    "    return None\n",
    "\n",
    "\n",
    "df['page_step1']=results.map(lambda x: x[0])\n",
    "df['page_step2']=results.map(Slice2)\n",
    "df['page_step3']=results.map(Slice3)\n",
    "\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "77029d8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "melt moves column data and stacks it vertically\n",
      "   key      a      b          c\n",
      "0    1   True  False  Batchelor\n",
      "1    2   True  False    Masters\n",
      "2    3  False   True  Doctorate\n",
      "   key letter    Boolean\n",
      "0    1      a       True\n",
      "1    2      a       True\n",
      "5    3      b       True\n",
      "6    1      c  Batchelor\n",
      "7    2      c    Masters\n",
      "8    3      c  Doctorate\n"
     ]
    }
   ],
   "source": [
    "print(\"melt moves column data and stacks it vertically\")\n",
    "d = {'key': [1,2,3], 'a': [True,True, False], 'b': [False,False,True],'c':['Batchelor','Masters','Doctorate']}\n",
    "df = pd.DataFrame(d)\n",
    "\n",
    "print(df)\n",
    "\n",
    "df2 = df.melt(id_vars=['key'], var_name = 'letter', value_name = 'Boolean')\n",
    "\n",
    "df2=df2.drop(df2.index[df2['Boolean'] == False])\n",
    "\n",
    "#df2 = df2.query('Bool == True')\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7333cf22",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}