python/Types-of-Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview\n",
    "\n",
    "Python 3 has several types of variables you can use:\n",
    "- [Integer](#Integer)\n",
    "- [Complex Integer](#Complex-Integer)\n",
    "- [Float](#Float)\n",
    "- [String](#String)\n",
    "- [Boolean](#Boolean)\n",
    "- [List](#List)\n",
    "- [Tuple](#Tuple)\n",
    "- [Dictionary](#Dictionary)\n",
    "- [Range](#Range)\n",
    "- [Slice](#Slice)\n",
    "- [Type](#Type)\n",
    "- [None](#None)\n",
    "- [Set](#Set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "- [Python Language Reference - Data Model](https://docs.python.org/3/reference/datamodel.html)\n",
    "- [Python 3 - Types](https://docs.python.org/3/library/types.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding integers results in an integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "z = x + y\n",
    "print( z )\n",
    "print( type ( z ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dividing integers results in a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "z = x / y\n",
    "print( z )\n",
    "print( type( z ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "z = x / x\n",
    "print( z )\n",
    "print( type( z ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round( 22.320000 ) = 22\n",
      "ceil( 22.320000 ) = 23\n",
      "floor( 22.320000 ) = 22\n",
      "math.sqrt( 22.320000 ) = 4.724405\n",
      "22.320000 ** 2 = 498.182400\n",
      "22.320000 ** 3 = 11119.431168\n",
      "22.320000 % 3 = 1.320000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = 22.32\n",
    "x_round = round(x)\n",
    "x_ceil = math.ceil(x)\n",
    "x_floor = math.floor(x)\n",
    "x_sqrt = math.sqrt(x)\n",
    "\n",
    "print( \"round( %f ) = %d\" %( x, x_round ) ) # Round\n",
    "print( \"ceil( %f ) = %d\" %( x, x_ceil ) ) # Ceil\n",
    "print( \"floor( %f ) = %d\" %( x, x_floor ) ) # Floor\n",
    "print( \"math.sqrt( %f ) = %f\" %( x, x_sqrt ) ) # Square Root\n",
    "print( \"%f ** 2 = %f\" %( x, x ** 2 ) ) # Cube\n",
    "print( \"%f ** 3 = %f\" %( x, x ** 3 ) ) # Square\n",
    "print( '%f %% 3 = %f' %( x, x % 3 ) ) # Escape % with %%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complex Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14j"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.14j\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2.5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 281,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string'"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = \"this is a string\"\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quotes and String Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first second \n"
     ]
    }
   ],
   "source": [
    "x = \"first\" # Double quote\n",
    "y = ' second ' # Single quote\n",
    "print( x + y ) # Must provide parens with print(), didn't previously in Python 2.x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenate number to string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string 23.23\n"
     ]
    }
   ],
   "source": [
    "x = \"string \"\n",
    "y = 23.23\n",
    "\n",
    "print( x + str( y ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first second \n",
      "22.3200\n",
      "33 22.32\n",
      "string\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = \"first\" # Double quote\n",
    "y = ' second ' # Single quote\n",
    "z = f'{ x }{ y }' # tick\n",
    "g = \"%6.4f\" % 22.32\n",
    "h = \"%2d %2.2f\" % ( 33.23, 22.32 )\n",
    "s = \"%s\" % \"string\" # this calls str()\n",
    "b = \"%r\" % True # this calls repr()\n",
    "\n",
    "print( z )\n",
    "print( g )\n",
    "print( h )\n",
    "print( s )\n",
    "print( b )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "print( x )\n",
    "print( y )\n",
    "print( type( y ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Numeric**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 < 20 = True\n",
      "10 > 20 = False\n",
      "10 == 20 = False\n",
      "10 != 20 = True\n",
      "\n",
      "10 < 10 = False\n",
      "10 > 10 = False\n",
      "10 == 10 = True\n",
      "10 != 10 = False\n",
      "\n",
      "10 and 20 = 20\n",
      "10 or 20 = 10\n",
      "not 20 = False\n",
      "not not 20 = True\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 20\n",
    "\n",
    "print( \"%d < %d = %r\" % ( x, y, x < y ) )\n",
    "print( \"%d > %d = %r\" % ( x, y, x > y ) )\n",
    "print( \"%d == %d = %r\" % ( x, y, x == y ) )\n",
    "print( \"%d != %d = %r\" % ( x, y, x != y ) )\n",
    "print()\n",
    "print( \"%d < %d = %r\" % ( x, x, x < x ) )\n",
    "print( \"%d > %d = %r\" % ( x, x, x > x ) )\n",
    "print( \"%d == %d = %r\" % ( x, x, x == x ) )\n",
    "print( \"%d != %d = %r\" % ( x, x, x != x ) )\n",
    "print()\n",
    "print( \"%d and %d = %r\" % ( x, y, x and y ) )\n",
    "print( \"%d or %d = %r\" % ( x, y, x or y ) )\n",
    "print( \"not %d = %r\" % ( y, not y ) )\n",
    "print( \"not not %d = %r\" % ( y, not not y ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True and False = False\n",
      "True or False = True\n",
      "not True = False\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "print( \"%r and %r = %r\" % ( x, y, x and y ) ) # AND\n",
    "print( \"%r or %r = %r\" % ( x, y, x or y ) ) # OR\n",
    "print( \"not %r = %r\" % ( x, not x ) ) # NOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bitwise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22 & 2 = 2\n",
      "22 | 2 = 22\n",
      "22 ^ 2 = 20\n",
      "22 << 2 = 88\n",
      "22 >> 2 = 5\n",
      "~22 = -23\n",
      "~~22 = 22\n"
     ]
    }
   ],
   "source": [
    "x = 22\n",
    "y = 2\n",
    "\n",
    "print( \"%d & %d = %d\" % ( x, y, x & y ) ) # Bitwise AND\n",
    "print( \"%d | %d = %d\" % ( x, y, x | y ) ) # Bitwise OR\n",
    "print( \"%d ^ %d = %d\" % ( x, y, x ^ y ) ) # Bitwise XOR\n",
    "print( \"%d << %d = %d\" % ( x, y, x << y ) ) # Bitwise left shift\n",
    "print( \"%d >> %d = %d\" % ( x, y, x >> y ) ) # Bitwise right shift\n",
    "print( \"~%d = %d\" % ( x, ~x ) ) # Bitwise NOT\n",
    "print( \"~~%d = %d\" % ( x, ~~x ) ) # Bitwise NOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "- [Notes about booleans and logical operators](https://thomas-cokelaer.info/tutorials/python/boolean.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 297,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**list.append()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 5]\n",
      "[1, 2, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "z = [ 1, 2 ]\n",
    "\n",
    "list.append( z, 5 ) \n",
    "print( z )\n",
    "\n",
    "z.append( 6 )\n",
    "print( z )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**list.insert()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 42, 4, 5, 6]\n",
      "[1, 2, 3, 42, 4, 5, 33, 6]\n"
     ]
    }
   ],
   "source": [
    "z = [ 1, 2, 3, 4, 5, 6 ]\n",
    "\n",
    "list.insert( z, 3, 42 )\n",
    "print( z )\n",
    "\n",
    "z.insert( 6, 33 )\n",
    "print( z )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**list.slice()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5]\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "z = [ 1, 2, 3, 4, 5, 6 ]\n",
    "print( z[ slice( 2, 5 ) ] )\n",
    "print( z )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [ 1, 2, 3 ]\n",
    "len( x )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixed Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['asdf', 2, 3.4, [2, 3, 4], range(0, 8)]"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [ 'asdf', 2, 3.4, [ 2, 3, 4 ], range( 8 ) ]\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion From Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = list( range( 1, 8 ) )\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion From Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['foo', 'cat']\n"
     ]
    }
   ],
   "source": [
    "x = { 'foo': 'bar', 'cat': 'dog' }\n",
    "print( list( x ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7]\n",
      "x[ 2  :  3      ] =  [3]\n",
      "x[ 2  :         ] =  [3, 4, 5, 6, 7]\n",
      "x[    :  3      ] =  [1, 2, 3]\n",
      "x[ -2 :         ] =  [6, 7]\n",
      "x[    : -2      ] =  [1, 2, 3, 4, 5]\n",
      "x[ -5 : -2      ] =  [3, 4, 5]\n",
      "x[  1 :  5      ] =  [2, 3, 4, 5]\n",
      "x[  1 :  5 :  1 ] =  [2, 3, 4, 5]\n",
      "x[  1 :  5 :  2 ] =  [2, 4]\n",
      "x[  1 :  5 :  3 ] =  [2, 5]\n",
      "x[  1 :  5 :  4 ] =  [2]\n",
      "x[    :    :  3 ] =  [1, 4, 7]\n",
      "x[    :    : -1 ] =  [7, 6, 5, 4, 3, 2, 1]\n",
      "x[    :    : -3 ] =  [7, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [ 1, 2, 3, 4, 5, 6, 7 ]\n",
    "print( x )\n",
    "\n",
    "print( 'x[ 2  :  3      ] = ', x[ 2 : 3 ] )\n",
    "print( 'x[ 2  :         ] = ', x[ 2 : ] )\n",
    "print( 'x[    :  3      ] = ', x[ : 3 ] )\n",
    "print( 'x[ -2 :         ] = ', x[ -2 : ] )\n",
    "print( 'x[    : -2      ] = ', x[ : -2 ] )\n",
    "print( 'x[ -5 : -2      ] = ', x[ -5 : -2 ] )\n",
    "print( 'x[  1 :  5      ] = ', x[ 1 : 5 ] )\n",
    "print( 'x[  1 :  5 :  1 ] = ', x[ 1 : 5 : 1 ] )\n",
    "print( 'x[  1 :  5 :  2 ] = ', x[ 1 : 5 : 2 ] )\n",
    "print( 'x[  1 :  5 :  3 ] = ', x[ 1 : 5 : 3 ] )\n",
    "print( 'x[  1 :  5 :  4 ] = ', x[ 1 : 5 : 4 ] )\n",
    "print( 'x[    :    :  3 ] = ', x[ ::3 ] )\n",
    "print( 'x[    :    : -1 ] = ', x[ ::-1 ] )\n",
    "print( 'x[    :    : -3 ] = ', x[ ::-3 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[ 0 ] =  1\n",
      "x[ 1 ] =  2\n",
      "x[ 2 ] =  3\n"
     ]
    }
   ],
   "source": [
    "x = [ 1, 2, 3, 4, 5, 6, 7 ]\n",
    "print( 'x[ 0 ] = ', x[0])\n",
    "print( 'x[ 1 ] = ', x[1])\n",
    "print( 'x[ 2 ] = ', x[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "- [The Python Tutorial - Data Structures](https://docs.python.org/3/tutorial/datastructures.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'string', 2.5)"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (1, 'string', 2.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert List to Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'a', 'b', 'c']\n",
      "(1, 2, 3, 'a', 'b', 'c')\n"
     ]
    }
   ],
   "source": [
    "l = [ 1, 2, 3, \"a\", \"b\", \"c\" ]\n",
    "\n",
    "t = tuple( l )\n",
    "\n",
    "print(l)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Packing / Unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 32)\n",
      "a b 32\n"
     ]
    }
   ],
   "source": [
    "t = 'a', 'b', 32 # Packing\n",
    "print( t )\n",
    "\n",
    "x, y, z = t # Unpacking\n",
    "print( x, y, z )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 1}"
      ]
     },
     "execution_count": 309,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = { \"key\": 1 }\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Empty Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "z = {}\n",
    "print( z )\n",
    "print( type( z ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looking Up a Key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar\n"
     ]
    }
   ],
   "source": [
    "k = { 'foo': 'bar', 'cat': 'dog' }\n",
    "print( k[ 'foo' ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 8)"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = range( 8 )\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range"
      ]
     },
     "execution_count": 312,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "slice(2, 4, None)"
      ]
     },
     "execution_count": 313,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = slice( 2, 4 )\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "slice"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( x )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing an Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "s = slice( 2, 4 )\n",
    "x = [ 1, 2, 3, 4, 5, 6, 7, 8 ]\n",
    "\n",
    "print( x[ s ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slice Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = [ 1, 2, 3, 4, 5, 6, 7, 8 ]\n",
    "print( x[ 2:4 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( type )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( None )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 34.29, 'a', 'b'}"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = { 'a', 'b', 1, 2, 34.29 }\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert String to Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'd', 'f', 's'}"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = set( 'asdf' )\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Empty Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = set()\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'> is not a set\n"
     ]
    }
   ],
   "source": [
    "z = {}\n",
    "z\n",
    "print( type( z ), \"is not a set\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = set( 'asdfghjkl;' )\n",
    "b = set( 'sdfl;' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'g', 'h', 'j', 'k'}"
      ]
     },
     "execution_count": 345,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{';', 'a', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 's'}"
      ]
     },
     "execution_count": 347,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{';', 'd', 'f', 'l', 's'}"
      ]
     },
     "execution_count": 348,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a & b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'g', 'h', 'j', 'k'}"
      ]
     },
     "execution_count": 349,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ^ b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}