4. Stackoverflow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "tf.enable_eager_execution()\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "import re\n",
    "from datetime import timedelta\n",
    "from scipy import stats\n",
    "from dateutil.relativedelta import relativedelta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                 date\n",
      "0 2020-06-13 00:43:04\n",
      "<class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "data=[\"06/Nov/2020:00:43:04 +0200\"]\n",
    "df=pd.DataFrame(data,columns=['date'])\n",
    "def MonthToNum(val):\n",
    "    dictMonth={'Jan':'1','Feb':'2','Mar':'3','Apr':'4','May':'5','Jun':'6','Jul':'7','Aug':'8','Sep':'9','Oct':'10','Nov':'11','Dec':'12'}\n",
    "    pattern = '|'.join(sorted(re.escape(k) for k in dictMonth))\n",
    "    #print(pattern)\n",
    "    retval=re.sub(pattern, lambda m: dictMonth.get(m.group(0)), val, flags=re.IGNORECASE)\n",
    "    return retval\n",
    "    \n",
    "df['date']=df['date'].apply(lambda x: pd.to_datetime(MonthToNum(x[0:11])+\" \"+x[12:20]) + timedelta(int(x[20:24])))\n",
    "print(df)\n",
    "print(type(df['date']))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 day, 0:54:03.294820\n"
     ]
    }
   ],
   "source": [
    "from datetime import timedelta\n",
    "\n",
    "time_string = '24:54:03.294820'\n",
    "hours, minutes, seconds = map(float, time_string.split(':'))\n",
    "t_delta = timedelta(hours=hours, minutes=minutes, seconds=seconds)\n",
    "print(t_delta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a'}\n"
     ]
    }
   ],
   "source": [
    "print({1 if 1==1 else 0 :'a'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'y': 10, 'z': 20, 'x': 30}\n"
     ]
    }
   ],
   "source": [
    "source = {'a': 10, 'b': 20, 'c': 30}\n",
    "#destination = {'x': None, 'y': None, 'z': None, 'qq': 'Some value'}\n",
    "mapping = {\"y\": \"a\", \"z\": \"b\", \"x\": \"c\"}\n",
    "result={k:source.get(v) for (k,v) in mapping.items()}\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 'A']\n"
     ]
    }
   ],
   "source": [
    "abc = [\"1\",\"2\",\"3\",\"4\",\"5\",\"A\"]\n",
    "\n",
    "def IsNumeric(value):\n",
    "     try:\n",
    "        return int(value)\n",
    "     except:\n",
    "        return value\n",
    "    \n",
    "abc=list(map(IsNumeric,abc))\n",
    "print(abc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'2013': '2013 this is data 3 (more data from 3)', '2016': '2016 this is data 6 (more data from 6)', '2011': '2011 this is data 1 (more data from 1)', '2012': '2012 this is data 2 (more data from 2)', '2014': '2014 this is data 4 (more data from 4)'}\n",
      "2016 this is data 6 (more data from 6)\n",
      "2014 this is data 4 (more data from 4)\n",
      "2013 this is data 3 (more data from 3)\n",
      "2012 this is data 2 (more data from 2)\n",
      "2011 this is data 1 (more data from 1)\n"
     ]
    }
   ],
   "source": [
    "longtext = \"\"\"2013 this is data 3 (more data from 3)\n",
    "2016 this is data 6 (more data from 6)\n",
    "2011 this is data 1 (more data from 1)\n",
    "2012 this is data 2 (more data from 2)\n",
    "2014 this is data 4 (more data from 4)\"\"\"\n",
    "\n",
    "data = longtext.splitlines()\n",
    "dct={}\n",
    "for x in data:\n",
    "    dct[(re.search(r'\\d{4}',x))[0]]=x\n",
    "    \n",
    "print(dct)    \n",
    "for i in sorted (dct.keys(),reverse=True) :  \n",
    "    print(dct.get(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.257297485586909e-10\n",
      "0.9999925941372282\n"
     ]
    }
   ],
   "source": [
    "def get_pvalue ( con_conv, test_conv, con_size, test_size):\n",
    "    lift= - abs(test_conv - con_conv)\n",
    "    scale_one = con_conv * (1-con_conv) * (1/con_size)\n",
    "    scale_two= test_conv * (1-test_conv) * (1/test_size)\n",
    "    scale_val = (scale_one + scale_two) **0.5\n",
    "    p_value=2*stats.norm.cdf(lift, loc=0, scale=scale_val)\n",
    "    return p_value\n",
    "\n",
    "def get_power(n, p1, p2, cl):\n",
    "    alpha = 1 - cl\n",
    "    qu = stats.norm.ppf(1 - alpha/2)\n",
    "    diff = abs(p2-p1)\n",
    "    bp = (p1+p2) / 2\n",
    "    \n",
    "    v1 = p1 * (1-p1)\n",
    "    v2 = p2 * (1-p2)\n",
    "    bv = bp * (1-bp)\n",
    "    \n",
    "    power_part_one = stats.norm.cdf((n**0.5 * diff - qu * (2 * bv)**0.5) / (v1+v2) ** 0.5)\n",
    "    power_part_two = 1 - stats.norm.cdf((n**0.5 * diff + qu * (2 * bv)**0.5) / (v1+v2) ** 0.5)\n",
    "    \n",
    "    power = power_part_one + power_part_two\n",
    "    \n",
    "    return (power)\n",
    "\n",
    "con_conv=0.034351\n",
    "test_conv=0.041984\n",
    "con_size=48236\n",
    "test_size=49867\n",
    "\n",
    "p_value=get_pvalue(con_conv,test_conv,con_size,test_size)\n",
    "print(p_value)\n",
    "\n",
    "power= get_power (test_size, con_conv, test_conv, 0.95)\n",
    "print(power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 one\n",
      "2 two\n",
      "2 dva\n",
      "3 three\n",
      "   variable phrase\n",
      "0         1    one\n",
      "1         2    two\n",
      "2         2    dva\n",
      "3         3  three\n",
      "{1: 'one', 2: 'two dva', 3: 'three'}\n"
     ]
    }
   ],
   "source": [
    "A = {1 : \"one\", 2 : \"two\"}\n",
    "B = {2 : \"dva\", 3 : \"three\"}\n",
    "\n",
    "z1=zip(A.keys(),A.values())\n",
    "z2=zip(B.keys(),B.values())\n",
    "\n",
    "mylist=[]\n",
    "mylist.append(list(z1))\n",
    "mylist.append(list(z2))\n",
    "\n",
    "variables=[]\n",
    "phrases=[]\n",
    "for item in mylist:\n",
    "    for k,v in item:\n",
    "        print(k,v)\n",
    "        variables.append(k)\n",
    "        phrases.append(v)\n",
    "df=pd.DataFrame(zip(variables,phrases),columns=['variable','phrase'])\n",
    "print(df)\n",
    "grpDictionary=df.groupby('variable').groups\n",
    "\n",
    "resultDictionary={}\n",
    "for key, values in grpDictionary.items():\n",
    "    resultDictionary[key]=\" \".join(df.iloc[values]['phrase'])\n",
    "\n",
    "print(resultDictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', '(a)one(a)two(a)three(a)four(a)five(a)six'), ('b', '(b)one(b)two'), ('c', '(c)one(c)two'), ('d', '(d)one')]\n"
     ]
    }
   ],
   "source": [
    "key_list=['a', 'a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'c', 'd']\n",
    "value_list=['(a)one', '(a)two', '(a)three', '(a)four', '(a)five', '(a)six', '(b)one', '(b)two', '(c)one', '(c)two', '(d)one']\n",
    "\n",
    "data=list(zip(key_list,value_list))\n",
    "df=pd.DataFrame(data,columns=['variable','phrase'])\n",
    "unique_variables=list(df.groupby('variable').groups)\n",
    "phrases=[]\n",
    "for key in unique_variables:\n",
    "    filter=df['variable']==key\n",
    "    phrases.append(\"\".join(df[filter]['phrase']))\n",
    "    \n",
    "print(list(zip(unique_variables,phrases)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['03-01-2020', '04-01-2020', '05-01-2020', '06-01-2020', '07-01-2020', '08-01-2020', '09-01-2020', '10-01-2020', '11-01-2020', '12-01-2020', '01-01-2021', '02-01-2021']\n"
     ]
    }
   ],
   "source": [
    "data=['Period1Monetary','Period2Monetary']\n",
    "current_date=pd.to_datetime('03-01-2020')\n",
    "\n",
    "mapDict={1:'Period1',2:'Period2'}\n",
    "\n",
    "columns=[]\n",
    "for i in range(1,13):\n",
    "    columns.append(current_date+ relativedelta(months=i-1))\n",
    "\n",
    "print([x.strftime('%m-%d-%Y') for x in columns])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Team   Player  Goals  YellowCards  RedCards\n",
      "0  Team1  Player1      2            1         1\n",
      "1  Team1  Player2      3            1         0\n",
      "2  Team2  Player3      2            2         1\n",
      "             Goals  RedCards  YellowCards  Totals\n",
      "Team                                             \n",
      "Team1          5.0       1.0          2.0     8.0\n",
      "Team2          2.0       1.0          2.0     5.0\n",
      "Grand Total    7.0       2.0          4.0    13.0\n"
     ]
    }
   ],
   "source": [
    "data=[('Team1','Player1',       2,             1,                    1),\n",
    "('Team1','Player2',       3,             1,                    0),\n",
    "('Team2','Player3',       2,             2,                    1)]\n",
    "\n",
    "df=pd.DataFrame(data=data,columns=['Team','Player','Goals', 'YellowCards','RedCards'])\n",
    "print(df)\n",
    "fp=df.pivot_table(index='Team',aggfunc='sum')\n",
    "fp['Totals'] = fp.sum(axis='columns')\n",
    "fp.loc[('Grand Total'), :] = fp.sum()\n",
    "print(fp)\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(10, 13), match='ABA'>\n",
      "<re.Match object; span=(14, 17), match='ABA'>\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "data=\"ABBAABBBAAABABABA\"\n",
    "matches=re.finditer(r\"(ABA)+\",data)\n",
    "for match in matches:\n",
    "    print(match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 2])\n",
      "tensor([[0., 0.],\n",
      "        [0., 0.]])\n",
      "Only Variables support sliced assignment\n",
      "[[5 6]\n",
      " [7 8]]\n",
      "<tf.RaggedTensor [[1, 2], [3, 4, 5]]>\n"
     ]
    }
   ],
   "source": [
    "#x = tf.Variable(tf.zeros([2, 2], tf.int32))\n",
    "x=torch.zeros(2,2)\n",
    "item = torch.tensor([[1, 2], [3, 4]])\n",
    "#tf.assign()\n",
    "print(x.shape)\n",
    "\n",
    "#x.assign([1,2],[3,4])\n",
    "print(x)\n",
    "print('Only Variables support sliced assignment')\n",
    "\n",
    "a=tf.Variable([[1,2],[3,4]])\n",
    "a.assign([[5,6], [7,8]])\n",
    "print(a.numpy())\n",
    "\n",
    "data_tensor=tf.ragged.constant([[1, 2], [3, 4,5]])\n",
    "print(data_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.)\n"
     ]
    }
   ],
   "source": [
    "a = torch.tensor([[[1., 0., 0., 0.]],\n",
    "        [[0., 1., 0., 0.]],\n",
    "        [[1., 0., 0., 0.]],\n",
    "        [[0., 0., 0., 1.]],\n",
    "        [[1., 0., 0., 0.]],\n",
    "        [[0., 0., 0., 1.]],\n",
    "        [[1., 0., 0., 0.]]])\n",
    "print(a[2][0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 2.],\n",
      "        [1., 0.],\n",
      "        [1., 1.],\n",
      "        [2., 1.],\n",
      "        [2., 2.],\n",
      "        [3., 0.],\n",
      "        [3., 2.],\n",
      "        [4., 1.],\n",
      "        [4., 2.],\n",
      "        [nan, 0.],\n",
      "        [nan, 1.],\n",
      "        [nan, 0.]], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "df = pd.DataFrame([[1, 2],\n",
    "                   [1, 0],\n",
    "                   [1, 1],\n",
    "                   [2, 1],\n",
    "                   [2, 2],\n",
    "                   [3, 0],\n",
    "                   [3, 2],\n",
    "                   [4, 1],\n",
    "                   [4, 2],\n",
    "                   [np.nan, 0],\n",
    "                   [np.nan, 1],\n",
    "                   [np.nan, 0]], columns=['ids', 'dim'])\n",
    "\n",
    "item=torch.tensor(df.values)\n",
    "print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   index  0  1  2\n",
      "2      3  7  1  9\n",
      "1      2  4  2  6\n",
      "0      1  1  5  3\n"
     ]
    }
   ],
   "source": [
    "d={1:[1,5,3],2:[4,2,6],3:[7,1,9]}\n",
    "\n",
    "df=pd.DataFrame(d).T\n",
    "df=df.reset_index()\n",
    "df=df.sort_values(by=1,axis=0)\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('Sunny',1,1,'Rich''Cinema'),\n",
    "('Sunny',0,1)"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}