Lezione 07 del 26 Apr 2022.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set e Fronzenset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Set: sequenza mutabile\n",
    "- Fronzenset: sequenza immutabile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3, 2, 1} # sequenza ove gli elementi devono essere univoci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'r'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set('abracadabra')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset({'a', 'b', 'c', 'd', 'r'})"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frozenset('abracadabra')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tra tutte i metodi di set solo copy() è supportato da fronzenset, dato che gli altri metodi mutano il set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grafici\n",
    "\n",
    "```python\n",
    "pip install pygal\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pygal\n",
    "\n",
    "def draw_xy(title, xvals, yvals):\n",
    "    \"\"\"\n",
    "    Draw xy plot with given x and y values.\n",
    "    \"\"\"\n",
    "    coords = [(xval, yval) for xval, yval in zip(xvals, yvals)]\n",
    "    xyplot = pygal.XY(height=400)\n",
    "    xyplot.title = title\n",
    "    xyplot.add(\"Data\", coords)\n",
    "    xyplot.render_in_browser()\n",
    "\n",
    "xvals = [0, 1, 3, 5, 6, 7, 9, 11, 12, 15]\n",
    "yvals = [4, 3, 1, 2, 2, 4, 5, 2, 1, 4]\n",
    "\n",
    "draw_xy(\"My XY Plot\", xvals, yvals)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## matplotlib (recommended)\n",
    "\n",
    "```python\n",
    "import matplotlib.pyplot as plt\n",
    "```\n",
    "\n",
    "Raccolta di funzioni che fanno funzionare matplotlib come MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot([1, 2, 3, 4])\n",
    "plt.ylabel('some numbers')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se matplotlib fosse limitato a lavorare con gli elenchi, sarebbe abbastanza inutile per l'elaborazione numerica. \n",
    "Generalmente, si usano array numpy. \n",
    "In effetti, tutte le sequenze vengono convertite internamente in array numpy.\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas\n",
    "\n",
    "La libreria Pandas viene utilizzata per analisi dei dati.\n",
    "\n",
    "```python\n",
    "from pandas import DataFrame, read_csv\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Bob', 968), ('Jessica', 155), ('Mary', 77), ('John', 578), ('Mel', 973)]\n"
     ]
    }
   ],
   "source": [
    "# Il set di dati consisterà in 5 nomi di bambini e il numero di nascite registrate per quell'anno (1880).\n",
    "\n",
    "names = ['Bob','Jessica','Mary','John','Mel']\n",
    "births = [968, 155, 77, 578, 973]\n",
    "\n",
    "# Per unire questi due elenchi insieme useremo la funzione zip.\n",
    "\n",
    "BabyDataSet = list(zip(names,births))\n",
    "print(BabyDataSet)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mary', 'Jessica', 'Jessica', 'Bob', 'Jessica', 'Jessica', 'Jessica', 'Mary', 'Mary', 'Mary']\n",
      "[968, 155, 77, 578, 973, 124, 155, 403, 199, 191]\n",
      "     Names  Births\n",
      "0     Mary     968\n",
      "1  Jessica     155\n",
      "2  Jessica      77\n",
      "3      Bob     578\n",
      "4  Jessica     973\n",
      "5  Jessica     124\n",
      "6  Jessica     155\n",
      "7     Mary     403\n",
      "8     Mary     199\n",
      "9     Mary     191\n",
      "Mary\n",
      "Jessica\n",
      "Bob\n",
      "John\n",
      "Mel\n",
      "count     1000\n",
      "unique       5\n",
      "top        Bob\n",
      "freq       206\n",
      "Name: Names, dtype: object\n",
      "         Births\n",
      "Names          \n",
      "Bob      106817\n",
      "Jessica   97826\n",
      "John      90705\n",
      "Mary      99438\n",
      "Mel      102319\n",
      "         Births\n",
      "Names          \n",
      "Bob      106817\n",
      "Mel      102319\n",
      "Mary      99438\n",
      "Jessica   97826\n",
      "John      90705\n",
      "       Births\n",
      "Names        \n",
      "Bob    106817\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='Names'>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from numpy import random\n",
    "\n",
    "names = ['Bob','Jessica','Mary','John','Mel']\n",
    "\n",
    "random.seed(500)\n",
    "random_names = [names[random.randint(low=0,high=len(names))] for i in range(1000)]\n",
    "\n",
    "print(random_names[:10])\n",
    "\n",
    "births = [random.randint(low=0,high=1000) for i in range(1000)]\n",
    "print(births[:10])\n",
    "\n",
    "BabyDataSet = list(zip(random_names,births))\n",
    "df = pd.DataFrame(data = BabyDataSet, columns=['Names', 'Births'])\n",
    "print(df[:10])\n",
    "\n",
    "df['Names'].unique()\n",
    "\n",
    "for x in df['Names'].unique():\n",
    "    print(x)\n",
    "\n",
    "print(df['Names'].describe())\n",
    "\n",
    "name = df.groupby('Names')\n",
    "\n",
    "df = name.sum()\n",
    "print(df)\n",
    "\n",
    "Sorted = df.sort_values(['Births'], ascending=False)\n",
    "print(Sorted)\n",
    "print(Sorted.head(1))\n",
    "\n",
    "df['Births'].plot.bar()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Numbers\n",
      "0         0\n",
      "1         1\n",
      "2         2\n",
      "3         3\n",
      "4         4\n",
      "5         5\n",
      "6         6\n",
      "7         7\n",
      "8         8\n",
      "9         9\n",
      "10       10\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "d = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "df = pd.DataFrame(data=d, columns=['Numbers'])\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Numbers\n",
      "0         1\n",
      "1         2\n",
      "2         3\n",
      "3         4\n",
      "4         5\n",
      "5         6\n",
      "6         7\n",
      "7         8\n",
      "8         9\n",
      "9        10\n",
      "10       11\n"
     ]
    }
   ],
   "source": [
    "df['Numbers'] = df['Numbers'] + 1\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   one  two\n",
      "a    1    2\n",
      "b    1    2\n",
      "Index(['a', 'b'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "d = {'one':[1,1],'two':[2,2]}\n",
    "i = ['a','b']\n",
    "\n",
    "# Create dataframe\n",
    "df = pd.DataFrame(data = d, index = i)\n",
    "print(df)\n",
    "\n",
    "print(df.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a  one    1\n",
      "   two    2\n",
      "b  one    1\n",
      "   two    2\n",
      "dtype: int64\n",
      "MultiIndex([('a', 'one'),\n",
      "            ('a', 'two'),\n",
      "            ('b', 'one'),\n",
      "            ('b', 'two')],\n",
      "           )\n"
     ]
    }
   ],
   "source": [
    "stack = df.stack()\n",
    "print(stack)\n",
    "print(stack.index) # Doppia indicizzazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     a  b\n",
      "one  1  1\n",
      "two  2  2\n"
     ]
    }
   ],
   "source": [
    "transpose = df.T\n",
    "print(transpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   one  two letter\n",
      "0    1    2      a\n",
      "1    1    2      a\n",
      "2    1    2      b\n",
      "3    1    2      b\n",
      "4    1    2      c\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "d = {'one':[1,1,1,1,1],\n",
    "     'two':[2,2,2,2,2],\n",
    "     'letter':['a','a', 'b', 'b', 'c']}\n",
    "df = pd.DataFrame(d)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        one  two\n",
      "letter          \n",
      "a         2    4\n",
      "b         2    4\n",
      "c         1    2\n"
     ]
    }
   ],
   "source": [
    "one = df.groupby('letter')\n",
    "print(one.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            two\n",
      "letter one     \n",
      "a      1      4\n",
      "b      1      4\n",
      "c      1      2\n",
      "MultiIndex([('a', 1),\n",
      "            ('b', 1),\n",
      "            ('c', 1)],\n",
      "           names=['letter', 'one'])\n"
     ]
    }
   ],
   "source": [
    "letterone = df.groupby(['letter','one']).sum()\n",
    "print(letterone)\n",
    "print(letterone.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  letter  one  two\n",
      "0      a    1    4\n",
      "1      b    1    4\n",
      "2      c    1    2\n"
     ]
    }
   ],
   "source": [
    "letterone = df.groupby(['letter','one'], as_index=False).sum()\n",
    "print(letterone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Animazioni\n",
    "\n",
    "Esistono due modi per creare animazioni utilizzando  Matplotlib: \n",
    "- Utilizzo della funzione pause() \n",
    "- Utilizzo della funzione FuncAnimation() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pause()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "  \n",
    "x = []\n",
    "y = []\n",
    "  \n",
    "for i in range(100):\n",
    "    x.append(i)\n",
    "    y.append(i)\n",
    "  \n",
    "    plt.xlim(0, 100)\n",
    "    plt.ylim(0, 100)\n",
    "      \n",
    "    \n",
    "    plt.plot(x, y, color = 'green')\n",
    "    plt.pause(0.01)\n",
    "  \n",
    "plt.show() # visualizzazione non è ottimale su Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FuncAnimation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.animation import FuncAnimation\n",
    "import numpy as np\n",
    "  \n",
    "x = []\n",
    "y = []\n",
    "figure, ax = plt.subplots()\n",
    "  \n",
    "# Setting limits for x and y axis\n",
    "ax.set_xlim(0, 100)\n",
    "ax.set_ylim(0, 12)\n",
    "  \n",
    "# Since plotting a single graph\n",
    "line,  = ax.plot(0, 0) \n",
    "  \n",
    "def animation_function(i):\n",
    "    x.append(i * 15)\n",
    "    y.append(i)  \n",
    "    line.set_xdata(x)\n",
    "    line.set_ydata(y)\n",
    "    return line,\n",
    "  \n",
    "animation = FuncAnimation(figure, func = animation_function, frames = np.arange(0, 10, 0.1), interval = 10)\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "8985369433b457479af44846aeaf0989574d367e9948a967101e5b1febcdd454"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "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.9.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}