DataTypes2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Types\n",
    "Since numpy elements are homogenious they all have the same data type.\n",
    "\n",
    "Both numeric and non-numeric data types are supportted in numpy.\n",
    "\n",
    "It is often necessary to explicitly choose wether to choose arrays of integers, floating point numbers, or complex values.\n",
    "\n",
    "The table below shows the datatypes supported by numpy:\n",
    "\n",
    "DataType | Description\n",
    "---| ---|\t\n",
    "bool_ | Boolean (true or false) stored as a byte\n",
    "int_ | Default integer type (same as C long; normally either int64 or int32)\n",
    "intc | Identical to C int (normally int32 or int64)\n",
    "intp | Integer used for indexing (same as C size_t; normally either int32 or int64)\n",
    "int8 | Byte (–128 to 127)\n",
    "int16 | Integer (–32768 to 32767)\n",
    "int32 | Integer (–2147483648 to 2147483647)\n",
    "int64 | Integer (–9223372036854775808 to 9223372036854775807)\n",
    "uint8 | Unsigned integer (0 to 255)\n",
    "uint16 | Unsigned integer (0 to 65535)\n",
    "uint32 | Unsigned integer (0 to 4294967295)\n",
    "uint64 | Unsigned integer (0 to 18446744073709551615)\n",
    "float_ | Shorthand for float64\n",
    "float16 | Half precision float: sign bit, 5-bit exponent, 10-bit mantissa\n",
    "float32 | Single precision float: sign bit, 8-bit exponent, 23-bit mantissa\n",
    "float64 | Double precision float: sign bit, 11-bit exponent, 52-bit mantissa\n",
    "complex_ | Shorthand for complex128\n",
    "complex64 | Complex number, represented by two 32-bit floats (real and imaginary components)\n",
    "complex128 | Complex number, represented by two 64-bit floats (real and imaginary components)\n",
    "object | Python object type; a value can be any Python object\n",
    "string_ | Fixed-length ASCII string type (1 byte per character); for example, to create a string dtype with length 10, use 'S10'\n",
    "unicode_ | Fixed-length Unicode type (number of bytes platform specific); same specification semantics as string_ (e.g., 'U10' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the dtype attribute to generate arrays of different data types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23, 45, 65])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([23, 45, 65], dtype=np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([45., 70., 20.])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([45, 70, 20], dtype=np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([59.+0.j, 30.+0.j, 20.+0.j])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([59, 30, 20], dtype=np.complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([60, 40, 32], dtype=object)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([60, 40, 32], dtype=np.object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([b'40', b'30', b'33'], dtype='|S2')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([40, 30, 33], dtype=np.string_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['66', '34', '90'], dtype='<U2')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([66, 34, 90], dtype=np.unicode_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Casting Arrays\n",
    "\n",
    "When computing with numpy arrays, the data type might get promoted from one type to another if required by the operation. eg, addding float-valued and complex-valued arrays. The result is a complex valued array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_one = np.array([34, 55, 70], dtype=np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_two = np.array([98, 30, 45], dtype=np.complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_three = data_one + data_two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('complex128')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_three.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can explicitly convert or cast an array from one data type to another using astype method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([33, 444, 800], dtype=np.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 = arr.astype(np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If _casting_ were to fail for some reason (like a string that cannot be converted to\n",
    "float64 ), a ValueError will be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}