EX_06/ex_06_pandas_1.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python37364bit49a3f827a4fd4d76955e1d5e29591a46",
   "display_name": "Python 3.7.3 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Hello Pandas!\n"
    }
   ],
   "source": [
    "print('Hello Pandas!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PANDAS\n",
    "##\n",
    "1. Pandas is an open-source library build on top of NumPy;;\n",
    "2. Pandas allows for analysis and data cleaning and preparations;\n",
    "3. Pandas excels in performance and productivity;\n",
    "4. Pandas also has built-in visualization features;\n",
    "5. Pandas can work with data from a wide variety of sources.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Science topics with Pandas:\n",
    "\n",
    "Here are the topics for our study about Pandas:\n",
    "\n",
    ".Series\n",
    "\n",
    ".DAtaFrames\n",
    "\n",
    ".Missing Data\n",
    "\n",
    ".GroupBy\n",
    "\n",
    ".Merging, Joinning, and Cocarenating\n",
    "\n",
    ".Operations\n",
    "\n",
    ".Data Input and Output\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first topic will be the Series:\n",
    "\n",
    "# SERIES "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST\n",
    "\n",
    "DATA\n",
    "\n",
    "ARRAY\n",
    "\n",
    "DICTIONARY\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pandas is build on top of NumPy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To start up PANDAS package\n",
    "import pandas as pd \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Four separate Python Object (LIST, DATA, ARRAY  AND DICTIONARY)\n",
    "labels=['a','b','c']\n",
    "my_data=[10,20,30]\n",
    "arr=np.array(my_data)\n",
    "d={'a':10,'b':20, 'c':30} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HOW TO CREATE A SERIES\n",
    "### First we'll need those four Python Object:\n",
    "\n",
    "1. LIST \n",
    "\n",
    "2. DATA\n",
    "\n",
    "3. ARRAY  and\n",
    "\n",
    "4. DICTIONARY "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Then we pass in our DATA to the Series Method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0    10\n1    20\n2    30\ndtype: int64"
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "source": [
    "# Series : It look a lot as np array, except that here it's very distinguish we have an INDEX and the actual DATA\n",
    "pd.Series(data=my_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Or our DATA together w/ LIST (labels):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "a    10\nb    20\nc    30\ndtype: int64"
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "source": [
    "# Now I specify that INDEX is iguals to the LIST labels \n",
    "# Now I have a label-INDEX Series\n",
    "pd.Series(data=my_data, index=labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In this very order: 1º DATA then 2º LIST: Series (DATA, LIST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "a    10\nb    20\nc    30\ndtype: int64"
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "# You don't need the constant-specifier as long as you put them in  the correct order\n",
    "pd.Series(my_data, labels) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Or finally, what's really cool!\n",
    "### Pass in the DICTIONARY:    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "a    10\nb    20\nc    30\ndtype: int64"
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "# Pandas takes the key as an INDEX, and the dictionary values as our DATA.\n",
    "# So that's a nice and fast way to quickly create a SERIES!\n",
    "pd.Series(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Series can hold pretty much almost any type of data object of Python as its data points and, more interesting than that, is we can pass in built-in functions like sum, print and len (it will hold references of these functions as data points)\n",
    "\n",
    "### We probably never actually use this, but this demonstrates the flexibility of the PANDAS Series as far as holding different object types!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic with Series\n",
    "\n",
    "Series (DATA, LIST)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "ser1=pd.Series([1,2,3,4], ['USA', 'USSR', 'GERMANY', 'JAPAN'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "USA        1\nUSSR       2\nGERMANY    3\nJAPAN      4\ndtype: int64"
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "source": [
    "ser1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ser2=pd.Series([1,2,5,4], ['USA','USSR', 'ITALY', 'JAPAN'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "USA      1\nUSSR     2\nITALY    5\nJAPAN    4\ndtype: int64"
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "source": [
    "ser2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "1"
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "# To rescue the data pass in the INDEX\n",
    "ser1['USA']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "1"
     },
     "metadata": {},
     "execution_count": 14
    }
   ],
   "source": [
    "ser1.USA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "GERMANY    NaN\nITALY      NaN\nJAPAN      8.0\nUSA        2.0\nUSSR       4.0\ndtype: float64"
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "source": [
    "# We can do arithmatic operations wir the Series too: \n",
    "ser1 + ser2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}