code/03-data-analysis-with-pandas/04-getting-elements-from-series.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[back](./03D-pandas-series-date-ranges.ipynb)\n",
    "\n",
    "---\n",
    "## `Getting Elements from Series`\n",
    "\n",
    "- Learn how to get elements and slices from Pandas Series\n",
    "    - [Getting individual elements of Series](#getting-individual-elements-of-series)\n",
    "    - [Getting slices of Series](#getting-slices-of-series)\n",
    "    - [Getting elements of Series based on boolean tests](#getting-elements-of-series-based-on-boolean-tests)\n",
    "    - [Retrieving all indexes and values](#retrieving-all-indexes-and-values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import pandas and numpy\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "d    4\n",
      "e    5\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Initialize a Series\n",
    "\n",
    "series = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])\n",
    "print(series)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Getting individual elements of Series`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First value by index:  1\n",
      "First value by index-label:  1\n",
      "Type of result:  <class 'numpy.int64'>\n"
     ]
    }
   ],
   "source": [
    "# Retrieving elements\n",
    "\n",
    "# Similar to list\n",
    "first = series[0]\n",
    "print('First value by index: ', first)\n",
    "print('First value by index-label: ', series['a'])\n",
    "\n",
    "# Uses numpy types, instead of Python types, in this case, it is numpy64 instead of Python int\n",
    "print('Type of result: ', type(first)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last value by index:  5\n",
      "Last value by index-label:  5\n",
      "\n",
      "Type of the element:  <class 'numpy.int64'>\n",
      "\n",
      "Last element retrieved via slicing:  e    5\n",
      "dtype: int64\n",
      "\n",
      "Type of the sliced element:  <class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "# Retrieving last element\n",
    "\n",
    "last = series[4]\n",
    "print('Last value by index: ', last)\n",
    "print('Last value by index-label: ', series['e'])\n",
    "\n",
    "print('\\nType of the element: ', type(last))\n",
    "\n",
    "# alternative way - slicing\n",
    "last = series[-1:]\n",
    "print('\\nLast element retrieved via slicing: ', last)\n",
    "\n",
    "# This is a pandas Series, because of slicing\n",
    "print('\\nType of the sliced element: ', type(last))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Fallback if element doesn't exist\n",
    "\n",
    "# This would cause an error as there is no element with the index 9 / label 'g'\n",
    "# tenth = series[9]\n",
    "# value_j = series['g']\n",
    "\n",
    "# Save way to retrieve elements from series to avoid error\n",
    "tenth = series.get(9)\n",
    "print(tenth)\n",
    "\n",
    "value_g = series.get('g')\n",
    "print(value_g)\n",
    "\n",
    "# Get value at index, if not present, get default value\n",
    "value_g = series.get('g', default=7)\n",
    "print(value_g)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Getting slices of Series`\n",
    "\n",
    "- [List way](#list-way)\n",
    "- [Pandas way](#pandas-way)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `List way`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First three:\n",
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "dtype: int64\n",
      "\n",
      "Last three:\n",
      "c    3\n",
      "d    4\n",
      "e    5\n",
      "dtype: int64\n",
      "\n",
      "Middle three:\n",
      "b    2\n",
      "c    3\n",
      "d    4\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Using the : (colon) syntax means, we are using slicing and it will always return a Series\n",
    "# Either one element / no elements, it will always return a Series\n",
    "\n",
    "# First 3 elements\n",
    "# first_three = series[0:3] or below way since it's the start index\n",
    "# here, 3 is the end index (exclusive) until where the value is required\n",
    "\n",
    "first_three = series[:3]\n",
    "print('First three:')\n",
    "print(first_three)\n",
    "\n",
    "# Last 3 elements\n",
    "# here, 5 is the end index (exclusive) until where the value is required\n",
    "last_three = series[2:5]\n",
    "print('\\nLast three:')\n",
    "print(last_three)\n",
    "\n",
    "# Middle 3\n",
    "middle_three = series[1:4]\n",
    "print('\\nMiddle three:')\n",
    "print(middle_three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Pandas way`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Middle three values of Series, retrieved via index:\n",
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "dtype: int64\n",
      "\n",
      "Slice of first three values of Series retrieved via labels:\n",
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Pandas specific way to retrieve slices of Series\n",
    "\n",
    "\n",
    "middle_three = series[[1, 2, 3]]\n",
    "print('Middle three values of Series, retrieved via index:')\n",
    "print(first_three)\n",
    "\n",
    "labeled_index = series[['a', 'b', 'c']]\n",
    "print('\\nSlice of first three values of Series retrieved via labels:')\n",
    "print(labeled_index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shuffled values from Series, using indexes:\n",
      "e    5\n",
      "b    2\n",
      "d    4\n",
      "a    1\n",
      "c    3\n",
      "dtype: int64\n",
      "\n",
      "Shuffled values from Series, using labels:\n",
      "b    2\n",
      "e    5\n",
      "a    1\n",
      "d    4\n",
      "c    3\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Shuffled values\n",
    "\n",
    "shuffled = series[[4, 1, 3, 0, 2]]\n",
    "print('Shuffled values from Series, using indexes:')\n",
    "print(shuffled)\n",
    "\n",
    "shuffled = series[['b', 'e', 'a', 'd', 'c']]\n",
    "print('\\nShuffled values from Series, using labels:')\n",
    "print(shuffled)\n",
    "\n",
    "# This way of accessing elements / slices might throw error if the index / label is not present\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Getting elements of Series based on boolean tests`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All values greater than 3:\n",
      "d    4\n",
      "e    5\n",
      "dtype: int64\n",
      "\n",
      "Values greater than 7:\n",
      "Series([], dtype: int64)\n"
     ]
    }
   ],
   "source": [
    "# Picking values based on simple boolean tests\n",
    "\n",
    "gt3 = series[series > 3]\n",
    "print('All values greater than 3:')\n",
    "print(gt3)\n",
    "\n",
    "# Accessing to get slices, will always return back Series\n",
    "gt7 = series[series > 7]\n",
    "print('\\nValues greater than 7:')\n",
    "print(gt7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Retrieving all indexes and values`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All indexes in series:\n",
      "Index(['a', 'b', 'c', 'd', 'e'], dtype='object')\n",
      "Type of indexes: <class 'pandas.core.indexes.base.Index'>\n",
      "\n",
      "All values in Series:\n",
      "[1 2 3 4 5]\n",
      "Type of values: <class 'numpy.ndarray'>\n",
      "\n",
      "Pandas array:\n",
      "<PandasArray>\n",
      "[1, 2, 3, 4, 5]\n",
      "Length: 5, dtype: int64\n",
      "Type of pandas_array: <class 'pandas.core.arrays.numpy_.PandasArray'>\n"
     ]
    }
   ],
   "source": [
    "# Accessing only values and/or indexes\n",
    "\n",
    "indexes = series.index\n",
    "print('All indexes in series:')\n",
    "print(indexes)\n",
    "print('Type of indexes:', type(indexes))\n",
    "\n",
    "values = series.values\n",
    "print('\\nAll values in Series:')\n",
    "print(values)\n",
    "\n",
    "# This will always return numpy arrays\n",
    "print('Type of values:', type(values))\n",
    "\n",
    "# Converting values into pandas array\n",
    "pandas_array = series.array\n",
    "print('\\nPandas array:')\n",
    "print(pandas_array)\n",
    "print('Type of pandas_array:', type(pandas_array))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "[next](./05-getting-properties-from-series.ipynb)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "0b4484ae063bf9ef0d5115063857dd0e382a2c73ed49a11a000ca56af03302b6"
  },
  "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
}