section1-02-files_lists_dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#  Files, Filepaths, Opening Files, Reading Data, CSV Files, Lists, Dictionaries\n",
    "\n",
    "In this section, we have two files in the data folder we want open and read data from a file and will store those values into a List and Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "If you aren't familiar with Lists, Dictionaries, or For-Loops review items below:\n",
    "\n",
    "#### List - https://www.w3schools.com/python/python_lists.asp\n",
    "\n",
    "Reference: https://www.w3schools.com/python/python_ref_list.asp\n",
    "\n",
    "Methods a List has: https://www.w3schools.com/python/python_lists_methods.asp\n",
    "\n",
    "Accessing Items in List: https://www.w3schools.com/python/python_lists_access.asp\n",
    "\n",
    "Adding items to a list: https://www.w3schools.com/python/python_lists_add.asp\n",
    "\n",
    "Remove items from list: https://www.w3schools.com/python/python_lists_remove.asp\n",
    "\n",
    "Loop through items in list: https://www.w3schools.com/python/python_lists_loop.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "#### Dictionary - https://www.w3schools.com/python/python_dictionaries.asp\n",
    "\n",
    "Methods a Dictionary has: https://www.w3schools.com/python/python_dictionaries_methods.asp\n",
    "\n",
    "Accessing Dictionary items: https://www.w3schools.com/python/python_dictionaries_access.asp\n",
    "\n",
    "Adding items to Dictionary: https://www.w3schools.com/python/python_dictionaries_add.asp\n",
    "\n",
    "Removing items from Dictionary:  https://www.w3schools.com/python/python_dictionaries_remove.asp\n",
    "\n",
    "Loop through items in a Dictionary: https://www.w3schools.com/python/python_dictionaries_loop.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "#### For-Loops - https://www.w3schools.com/python/python_for_loops.asp\n",
    "\n",
    "https://www.dataquest.io/blog/python-for-loop-tutorial/\n",
    "\n",
    "https://realpython.com/python-for-loop/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Files & File Paths\n",
    "We'll be working with two csv files in this section:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/pycon-files.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) pycon_sponsors.csv - contains list of sponsors of Pycon, symbol (if company is publicly traded), and sponsorship level at Pycon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pycon_sponsors_filename = 'pycon_sponsors.csv'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/pycon_sponsors.png\" align=\"left\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "2) pycon_sponsor_levels_filename - contains sponsorship level and $ amount of each level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pycon_sponsor_levels_filename = \"pycon_sponsor_levels.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/pycon_sponsor_levels.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pycon_sponsors_filename)\n",
    "# str\n",
    "# they are type string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why not just use the full filepath of the file?\n",
    "\n",
    "We could, but we are kind of stuck with the filepaths as they are.   And, as I'm about to show, we can dynamically create filepaths using modules in the Standard Library.  This will come in handy when we eventually get to the automaion section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pycon_sponsors_filepath = \"C:\\projects\\spreadsheets-to-dataframes\\data\\pycon_sponsors.csv\"\n",
    "pycon_sponsor_levels_filepath = \"C:\\projects\\spreadsheets-to-dataframes\\data\\pycon_sponsor_levels.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "# Pre-Installed Excel Add-ins -> The Python Standard Library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/excel-pre-installed-add-ins.png\" align=\"left\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like Excel Add-Ins, Python has a bunch of built-in add-in that we can access, but we need to \"enable\" in order to use. We do this by using the \"import\" keyword and then the name of the module.\n",
    "\n",
    "<img src=\"img/basics/standard-library-import.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are curious what the difference between a module, package, or library are:\n",
    "\n",
    "https://realpython.com/lessons/scripts-modules-packages-and-libraries/\n",
    "\n",
    "https://stackoverflow.com/questions/19198166/whats-the-difference-between-a-module-and-a-library-in-python\n",
    "\n",
    "https://docs.python.org/3/tutorial/modules.html\n",
    "\n",
    "https://www.learnpython.org/en/Modules_and_Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "# The Standary Library\n",
    "\n",
    "The Python Standard Library: https://docs.python.org/3/library/\n",
    "\n",
    "Intro to Standard Library:  https://docs.python.org/3/library/intro.html\n",
    "\n",
    "Brief Tour of the Standard Library: https://docs.python.org/3/tutorial/stdlib.html\n",
    "\n",
    "### Books & Resources\n",
    "\n",
    "https://www.amazon.com/Python-Standard-Library-Example-Developers/dp/0134291050 <- Book with great examples for using The Standard Library\n",
    "\n",
    "https://pymotw.com/3/index.html <- website for book\n",
    "\n",
    "There are quite a few available..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/standard-library.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.python.org/3/py-modindex.html\n",
    "\n",
    "The ones I use the most (probably missing some):\n",
    "\n",
    "# Operating System\n",
    "https://docs.python.org/3/library/os.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/sys.html\n",
    "\n",
    "# Filepaths and Directories\n",
    "https://docs.python.org/3/library/filesys.html\n",
    "\n",
    "https://docs.python.org/3/library/pathlib.html\n",
    "\n",
    "https://docs.python.org/3/library/os.path.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/glob.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/shutil.html - Move/Copy/Delete Files/Folders\n",
    "\n",
    "https://docs.python.org/3/library/__main__.html (Used in Tutorial)\n",
    "\n",
    "# Data Handling\n",
    "https://docs.python.org/3/library/csv.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/json.html - JSON\n",
    "\n",
    "https://docs.python.org/3/library/html.html - HTML\n",
    "\n",
    "https://docs.python.org/3/library/sqlite3.html - SQLite3\n",
    "\n",
    "https://docs.python.org/3/library/archiving.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/zipfile.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/base64.html\n",
    "\n",
    "https://docs.python.org/3/library/xml.html\n",
    "\n",
    "https://docs.python.org/3/library/dataclasses.html\n",
    "\n",
    "# Logging & Testing\n",
    "\n",
    "https://docs.python.org/3/library/logging.html\n",
    "\n",
    "https://docs.python.org/3/library/unittest.html\n",
    "\n",
    "https://docs.python.org/3/library/pdb.html\n",
    "\n",
    "https://docs.python.org/3/library/timeit.html\n",
    "\n",
    "# Date Time\n",
    "https://python.readthedocs.io/en/stable/library/datetime.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/time.html\n",
    "\n",
    "# Pretty Print\n",
    "https://python.readthedocs.io/en/stable/library/pprint.html (Used in tutorial)\n",
    "\n",
    "# Numeric & Math Modules\n",
    "https://docs.python.org/3/library/numeric.html\n",
    "\n",
    "https://docs.python.org/3/library/math.html\n",
    "\n",
    "# Internet & Networking\n",
    "https://docs.python.org/3/library/urllib.html (Used in tutorial)\n",
    "\n",
    "https://docs.python.org/3/library/email.html\n",
    "\n",
    "https://docs.python.org/3/library/http.html\n",
    "\n",
    "https://docs.python.org/3/library/socket.html\n",
    "\n",
    "# Functional Programming Modules (Intermediate-Advanced)\n",
    "https://docs.python.org/3/library/functional.html\n",
    "\n",
    "# Conncurrent Execution (Intermediate-Advanced)\n",
    "https://docs.python.org/3/library/threading.html\n",
    "\n",
    "https://docs.python.org/3/library/multiprocessing.html\n",
    "\n",
    "https://docs.python.org/3/library/queue.html\n",
    "\n",
    "https://docs.python.org/3/library/subprocess.html\n",
    "\n",
    "https://docs.python.org/3/library/asyncio.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Files & File Paths\n",
    "\n",
    "Alright, the reason I'm bringing up the Standard Library (above) is that we need to figure out the directory we are working in...\n",
    "\n",
    "Luckily, Python has a module ( use \"os\" from the standard library to find this out.\n",
    "\n",
    "## Working with Files and Filepaths using the OS Library\n",
    "\n",
    "documentation: https://docs.python.org/3/library/os.html\n",
    "\n",
    "examples: https://pymotw.com/3/file_access.html\n",
    "\n",
    "Like I mentioned above, in order to use modules in the standard library we need to import them first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the dir() function to print out list of functions we can performL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DirEntry',\n",
       " 'F_OK',\n",
       " 'GenericAlias',\n",
       " 'Mapping',\n",
       " 'MutableMapping',\n",
       " 'O_APPEND',\n",
       " 'O_BINARY',\n",
       " 'O_CREAT',\n",
       " 'O_EXCL',\n",
       " 'O_NOINHERIT',\n",
       " 'O_RANDOM',\n",
       " 'O_RDONLY',\n",
       " 'O_RDWR',\n",
       " 'O_SEQUENTIAL',\n",
       " 'O_SHORT_LIVED',\n",
       " 'O_TEMPORARY',\n",
       " 'O_TEXT',\n",
       " 'O_TRUNC',\n",
       " 'O_WRONLY',\n",
       " 'P_DETACH',\n",
       " 'P_NOWAIT',\n",
       " 'P_NOWAITO',\n",
       " 'P_OVERLAY',\n",
       " 'P_WAIT',\n",
       " 'PathLike',\n",
       " 'R_OK',\n",
       " 'SEEK_CUR',\n",
       " 'SEEK_END',\n",
       " 'SEEK_SET',\n",
       " 'TMP_MAX',\n",
       " 'W_OK',\n",
       " 'X_OK',\n",
       " '_AddedDllDirectory',\n",
       " '_Environ',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_check_methods',\n",
       " '_execvpe',\n",
       " '_exists',\n",
       " '_exit',\n",
       " '_fspath',\n",
       " '_get_exports_list',\n",
       " '_walk',\n",
       " '_wrap_close',\n",
       " 'abc',\n",
       " 'abort',\n",
       " 'access',\n",
       " 'add_dll_directory',\n",
       " 'altsep',\n",
       " 'chdir',\n",
       " 'chmod',\n",
       " 'close',\n",
       " 'closerange',\n",
       " 'cpu_count',\n",
       " 'curdir',\n",
       " 'defpath',\n",
       " 'device_encoding',\n",
       " 'devnull',\n",
       " 'dup',\n",
       " 'dup2',\n",
       " 'environ',\n",
       " 'error',\n",
       " 'execl',\n",
       " 'execle',\n",
       " 'execlp',\n",
       " 'execlpe',\n",
       " 'execv',\n",
       " 'execve',\n",
       " 'execvp',\n",
       " 'execvpe',\n",
       " 'extsep',\n",
       " 'fdopen',\n",
       " 'fsdecode',\n",
       " 'fsencode',\n",
       " 'fspath',\n",
       " 'fstat',\n",
       " 'fsync',\n",
       " 'ftruncate',\n",
       " 'get_exec_path',\n",
       " 'get_handle_inheritable',\n",
       " 'get_inheritable',\n",
       " 'get_terminal_size',\n",
       " 'getcwd',\n",
       " 'getcwdb',\n",
       " 'getenv',\n",
       " 'getlogin',\n",
       " 'getpid',\n",
       " 'getppid',\n",
       " 'isatty',\n",
       " 'kill',\n",
       " 'linesep',\n",
       " 'link',\n",
       " 'listdir',\n",
       " 'lseek',\n",
       " 'lstat',\n",
       " 'makedirs',\n",
       " 'mkdir',\n",
       " 'name',\n",
       " 'open',\n",
       " 'pardir',\n",
       " 'path',\n",
       " 'pathsep',\n",
       " 'pipe',\n",
       " 'popen',\n",
       " 'putenv',\n",
       " 'read',\n",
       " 'readlink',\n",
       " 'remove',\n",
       " 'removedirs',\n",
       " 'rename',\n",
       " 'renames',\n",
       " 'replace',\n",
       " 'rmdir',\n",
       " 'scandir',\n",
       " 'sep',\n",
       " 'set_handle_inheritable',\n",
       " 'set_inheritable',\n",
       " 'spawnl',\n",
       " 'spawnle',\n",
       " 'spawnv',\n",
       " 'spawnve',\n",
       " 'st',\n",
       " 'startfile',\n",
       " 'stat',\n",
       " 'stat_result',\n",
       " 'statvfs_result',\n",
       " 'strerror',\n",
       " 'supports_bytes_environ',\n",
       " 'supports_dir_fd',\n",
       " 'supports_effective_ids',\n",
       " 'supports_fd',\n",
       " 'supports_follow_symlinks',\n",
       " 'symlink',\n",
       " 'sys',\n",
       " 'system',\n",
       " 'terminal_size',\n",
       " 'times',\n",
       " 'times_result',\n",
       " 'truncate',\n",
       " 'umask',\n",
       " 'uname_result',\n",
       " 'unlink',\n",
       " 'unsetenv',\n",
       " 'urandom',\n",
       " 'utime',\n",
       " 'waitpid',\n",
       " 'waitstatus_to_exitcode',\n",
       " 'walk',\n",
       " 'write']"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(os)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can get the current working directory or folder where python file is located\n",
    "\n",
    "documentation: https://docs.python.org/3/library/os.html#os.getcwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\projects\\spreadsheets-to-dataframes\n"
     ]
    }
   ],
   "source": [
    "current_directory = os.getcwd()\n",
    "\n",
    "print(current_directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\projects\\spreadsheets-to-dataframes\\data\\pycon_sponsor_levels.csv\n",
      "C:\\projects\\spreadsheets-to-dataframes\\data\\pycon_sponsors.csv\n"
     ]
    }
   ],
   "source": [
    "# What we are aiming for\n",
    "print(pycon_sponsor_levels_filepath)\n",
    "print(pycon_sponsors_filepath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have the current directory, we just need to concat the data folder and the filename.\n",
    "\n",
    "In this example, the folder with the files we want is in a sub-directory called data we can use the os.path.join() function to create a filepath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\projects\\spreadsheets-to-dataframes\\data\\pycon_sponsors.csv\n"
     ]
    }
   ],
   "source": [
    "pycon_sponsors_filepath = os.path.join(current_directory, \"data\", pycon_sponsors_filename)\n",
    "print(pycon_sponsors_filepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\projects\\spreadsheets-to-dataframes\\data\\pycon_sponsor_levels.csv\n"
     ]
    }
   ],
   "source": [
    "pycon_sponsor_levels_filepath = os.path.join(current_directory, \"data\", pycon_sponsor_levels_filename)\n",
    "print(pycon_sponsor_levels_filepath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can verify that a file exists using the os.path.exists function returns a True if the file exists and False if file doesn't exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.exists(pycon_sponsors_filepath)\n",
    "# Out[124]: True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File Exists\n"
     ]
    }
   ],
   "source": [
    "if os.path.exists(pycon_sponsors_filepath):\n",
    "    print(\"File Exists\")\n",
    "else:\n",
    "    print(\"File doesn't Exist\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.exists(pycon_sponsor_levels_filepath)\n",
    "# Out[124]: True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "# Open & Read Files\n",
    "\n",
    "Now that we know our files exist, we can use the built-in open() function to open & read the data\n",
    "Three step process:\n",
    "\n",
    "    1) open file\n",
    "    2) read file contents\n",
    "    3) close the file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "open - built-in function\n",
    "documentation - https://docs.python.org/3/library/functions.html#open\n",
    "\n",
    "examples: https://www.w3schools.com/python/ref_func_open.asp\n",
    "\n",
    "more examples: https://thepythonguru.com/python-how-to-read-and-write-files/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function open in module io:\n",
      "\n",
      "open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)\n",
      "    Open file and return a stream.  Raise OSError upon failure.\n",
      "    \n",
      "    file is either a text or byte string giving the name (and the path\n",
      "    if the file isn't in the current working directory) of the file to\n",
      "    be opened or an integer file descriptor of the file to be\n",
      "    wrapped. (If a file descriptor is given, it is closed when the\n",
      "    returned I/O object is closed, unless closefd is set to False.)\n",
      "    \n",
      "    mode is an optional string that specifies the mode in which the file\n",
      "    is opened. It defaults to 'r' which means open for reading in text\n",
      "    mode.  Other common values are 'w' for writing (truncating the file if\n",
      "    it already exists), 'x' for creating and writing to a new file, and\n",
      "    'a' for appending (which on some Unix systems, means that all writes\n",
      "    append to the end of the file regardless of the current seek position).\n",
      "    In text mode, if encoding is not specified the encoding used is platform\n",
      "    dependent: locale.getpreferredencoding(False) is called to get the\n",
      "    current locale encoding. (For reading and writing raw bytes use binary\n",
      "    mode and leave encoding unspecified.) The available modes are:\n",
      "    \n",
      "    ========= ===============================================================\n",
      "    Character Meaning\n",
      "    --------- ---------------------------------------------------------------\n",
      "    'r'       open for reading (default)\n",
      "    'w'       open for writing, truncating the file first\n",
      "    'x'       create a new file and open it for writing\n",
      "    'a'       open for writing, appending to the end of the file if it exists\n",
      "    'b'       binary mode\n",
      "    't'       text mode (default)\n",
      "    '+'       open a disk file for updating (reading and writing)\n",
      "    'U'       universal newline mode (deprecated)\n",
      "    ========= ===============================================================\n",
      "    \n",
      "    The default mode is 'rt' (open for reading text). For binary random\n",
      "    access, the mode 'w+b' opens and truncates the file to 0 bytes, while\n",
      "    'r+b' opens the file without truncation. The 'x' mode implies 'w' and\n",
      "    raises an `FileExistsError` if the file already exists.\n",
      "    \n",
      "    Python distinguishes between files opened in binary and text modes,\n",
      "    even when the underlying operating system doesn't. Files opened in\n",
      "    binary mode (appending 'b' to the mode argument) return contents as\n",
      "    bytes objects without any decoding. In text mode (the default, or when\n",
      "    't' is appended to the mode argument), the contents of the file are\n",
      "    returned as strings, the bytes having been first decoded using a\n",
      "    platform-dependent encoding or using the specified encoding if given.\n",
      "    \n",
      "    'U' mode is deprecated and will raise an exception in future versions\n",
      "    of Python.  It has no effect in Python 3.  Use newline to control\n",
      "    universal newlines mode.\n",
      "    \n",
      "    buffering is an optional integer used to set the buffering policy.\n",
      "    Pass 0 to switch buffering off (only allowed in binary mode), 1 to select\n",
      "    line buffering (only usable in text mode), and an integer > 1 to indicate\n",
      "    the size of a fixed-size chunk buffer.  When no buffering argument is\n",
      "    given, the default buffering policy works as follows:\n",
      "    \n",
      "    * Binary files are buffered in fixed-size chunks; the size of the buffer\n",
      "      is chosen using a heuristic trying to determine the underlying device's\n",
      "      \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n",
      "      On many systems, the buffer will typically be 4096 or 8192 bytes long.\n",
      "    \n",
      "    * \"Interactive\" text files (files for which isatty() returns True)\n",
      "      use line buffering.  Other text files use the policy described above\n",
      "      for binary files.\n",
      "    \n",
      "    encoding is the name of the encoding used to decode or encode the\n",
      "    file. This should only be used in text mode. The default encoding is\n",
      "    platform dependent, but any encoding supported by Python can be\n",
      "    passed.  See the codecs module for the list of supported encodings.\n",
      "    \n",
      "    errors is an optional string that specifies how encoding errors are to\n",
      "    be handled---this argument should not be used in binary mode. Pass\n",
      "    'strict' to raise a ValueError exception if there is an encoding error\n",
      "    (the default of None has the same effect), or pass 'ignore' to ignore\n",
      "    errors. (Note that ignoring encoding errors can lead to data loss.)\n",
      "    See the documentation for codecs.register or run 'help(codecs.Codec)'\n",
      "    for a list of the permitted encoding error strings.\n",
      "    \n",
      "    newline controls how universal newlines works (it only applies to text\n",
      "    mode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as\n",
      "    follows:\n",
      "    \n",
      "    * On input, if newline is None, universal newlines mode is\n",
      "      enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n",
      "      these are translated into '\\n' before being returned to the\n",
      "      caller. If it is '', universal newline mode is enabled, but line\n",
      "      endings are returned to the caller untranslated. If it has any of\n",
      "      the other legal values, input lines are only terminated by the given\n",
      "      string, and the line ending is returned to the caller untranslated.\n",
      "    \n",
      "    * On output, if newline is None, any '\\n' characters written are\n",
      "      translated to the system default line separator, os.linesep. If\n",
      "      newline is '' or '\\n', no translation takes place. If newline is any\n",
      "      of the other legal values, any '\\n' characters written are translated\n",
      "      to the given string.\n",
      "    \n",
      "    If closefd is False, the underlying file descriptor will be kept open\n",
      "    when the file is closed. This does not work when a file name is given\n",
      "    and must be True in that case.\n",
      "    \n",
      "    A custom opener can be used by passing a callable as *opener*. The\n",
      "    underlying file descriptor for the file object is then obtained by\n",
      "    calling *opener* with (*file*, *flags*). *opener* must return an open\n",
      "    file descriptor (passing os.open as *opener* results in functionality\n",
      "    similar to passing None).\n",
      "    \n",
      "    open() returns a file object whose type depends on the mode, and\n",
      "    through which the standard file operations such as reading and writing\n",
      "    are performed. When open() is used to open a file in a text mode ('w',\n",
      "    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\n",
      "    a file in a binary mode, the returned class varies: in read binary\n",
      "    mode, it returns a BufferedReader; in write binary and append binary\n",
      "    modes, it returns a BufferedWriter, and in read/write mode, it returns\n",
      "    a BufferedRandom.\n",
      "    \n",
      "    It is also possible to use a string or bytearray as a file for both\n",
      "    reading and writing. For strings StringIO can be used like a file\n",
      "    opened in a text mode, and for bytes a BytesIO can be used like a file\n",
      "    opened in a binary mode.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(open)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1) open file - returns a file variable/object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# file = open(pycon_sponsors_filepath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at documenation from help, we could also specify mode=\"r\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(pycon_sponsors_filepath, mode='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we were writing data (saving file) we sould use mode='w'\n",
    "\n",
    "file = open(pycon_sponsors_filepath, mode='w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_io.TextIOWrapper"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(file)\n",
    "# Out[130]: _io.TextIOWrapper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we can use dir() function on anything to see types of things we can do to it using . (dot) notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['_CHUNK_SIZE',\n",
       " '__class__',\n",
       " '__del__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__enter__',\n",
       " '__eq__',\n",
       " '__exit__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__next__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '_checkClosed',\n",
       " '_checkReadable',\n",
       " '_checkSeekable',\n",
       " '_checkWritable',\n",
       " '_finalizing',\n",
       " 'buffer',\n",
       " 'close',\n",
       " 'closed',\n",
       " 'detach',\n",
       " 'encoding',\n",
       " 'errors',\n",
       " 'fileno',\n",
       " 'flush',\n",
       " 'isatty',\n",
       " 'line_buffering',\n",
       " 'mode',\n",
       " 'name',\n",
       " 'newlines',\n",
       " 'read',\n",
       " 'readable',\n",
       " 'readline',\n",
       " 'readlines',\n",
       " 'reconfigure',\n",
       " 'seek',\n",
       " 'seekable',\n",
       " 'tell',\n",
       " 'truncate',\n",
       " 'writable',\n",
       " 'write',\n",
       " 'write_through',\n",
       " 'writelines']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2) read the file contents\n",
    "Once the file is open, we can read the data using the read() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pycon_sponsors_data = file.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'symbol,name,sponsor_level\\nGOOG,ALPHABET INC.,VISIONARY\\nAMZN,AMAZON COM INC,SUSTAINABILITY\\n#N/A,BLOOMBERG,VISIONARY\\nCOF,CAPITAL ONE FINANCIAL CORP,MAINTAINING\\nGLW,CORNING INC,MAINTAINING\\nESTC,ELASTIC N.V.,PARTNER\\nFB,FACEBOOK INC,SUSTAINABILITY\\n#N/A,HUAWEI TECHNOLOGIES,SUSTAINABILITY\\nIBM,INTERNATIONAL BUSINESS MACHINES CORP,CONTRIBUTING\\nJPM,JPMORGAN CHASE & CO,SUPPORTING\\nMSFT,MICROSOFT CORP,VISIONARY\\nNFLX,NETFLIX INC,PARTNER\\nCRM,SALESFORCE.COM INC.,SUSTAINABILITY\\nWORK,SLACK TECHNOLOGIES INC.,MAINTAINING\\n'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsors_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 3) Close the file\n",
    "we need to close the file otherwise file will be locked from use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "symbol,name,sponsor_level\n",
      "GOOG,ALPHABET INC.,VISIONARY\n",
      "AMZN,AMAZON COM INC,SUSTAINABILITY\n",
      "#N/A,BLOOMBERG,VISIONARY\n",
      "COF,CAPITAL ONE FINANCIAL CORP,MAINTAINING\n",
      "GLW,CORNING INC,MAINTAINING\n",
      "ESTC,ELASTIC N.V.,PARTNER\n",
      "FB,FACEBOOK INC,SUSTAINABILITY\n",
      "#N/A,HUAWEI TECHNOLOGIES,SUSTAINABILITY\n",
      "IBM,INTERNATIONAL BUSINESS MACHINES CORP,CONTRIBUTING\n",
      "JPM,JPMORGAN CHASE & CO,SUPPORTING\n",
      "MSFT,MICROSOFT CORP,VISIONARY\n",
      "NFLX,NETFLIX INC,PARTNER\n",
      "CRM,SALESFORCE.COM INC.,SUSTAINABILITY\n",
      "WORK,SLACK TECHNOLOGIES INC.,MAINTAINING\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(pycon_sponsors_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pycon_sponsors_data)\n",
    "# str\n",
    "# Since the contents of the file we just opened is a string type, we can perform all the methods availible to string variables/objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "For Example:\n",
    "# replace a value with another value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ticker,name,sponsor_level\\nGOOG,ALPHABET INC.,VISIONARY\\nAMZN,AMAZON COM INC,SUSTAINABILITY\\n#N/A,BLOOMBERG,VISIONARY\\nCOF,CAPITAL ONE FINANCIAL CORP,MAINTAINING\\nGLW,CORNING INC,MAINTAINING\\nESTC,ELASTIC N.V.,PARTNER\\nFB,FACEBOOK INC,SUSTAINABILITY\\n#N/A,HUAWEI TECHNOLOGIES,SUSTAINABILITY\\nIBM,INTERNATIONAL BUSINESS MACHINES CORP,CONTRIBUTING\\nJPM,JPMORGAN CHASE & CO,SUPPORTING\\nMSFT,MICROSOFT CORP,VISIONARY\\nNFLX,NETFLIX INC,PARTNER\\nCRM,SALESFORCE.COM INC.,SUSTAINABILITY\\nWORK,SLACK TECHNOLOGIES INC.,MAINTAINING\\n'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsors_data.replace(\"symbol\", \"ticker\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Find location of a Value in a String\n",
    "\n",
    "online examples: https://www.w3schools.com/python/ref_string_find.asp\n",
    "\n",
    "remember the data is all capital letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "372"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsors_data.find(\"MSFT\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "\n",
    "# Index & Slice into String objects\n",
    "\n",
    "As we touched on briefly in the last section, we can \"slice\" & \"index\" into certain types of variables/objects.  Again, this is an important concept to know about when it comes to Pandas, Lists, and Dictionaries.\n",
    "\n",
    "example: https://www.w3schools.com/python/gloss_python_string_slice.asp\n",
    "\n",
    "index & slice strings: https://www.digitalocean.com/community/tutorials/how-to-index-and-slice-strings-in-python-3\n",
    "\n",
    "https://realpython.com/python-string-split-concatenate-join/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "',MICROSOFT CORP,VISIONARY\\nNFLX,NETFLIX INC,PARTNER\\nCRM,SALESFORCE.COM INC.,SUSTAINABILITY\\nWORK,SLACK TECHNOLOGIES INC.,MAINTAINING\\n'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsors_data[376:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "402"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsors_data.find(\"NFLX\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "',MICROSOFT CORP,VISIONARY\\nNFLX'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsors_data[376:406]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save as variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "microsoft_string = pycon_sponsors_data[376:406]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "',MICROSOFT CORP,VISIONARY\\nNFLX'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "microsoft_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(microsoft_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "again, its a string type aka text data\n",
    "\n",
    "which means we can perform string methods\n",
    "\n",
    "for example, we can remove \\n using using the strip() method\n",
    "\n",
    "https://stackoverflow.com/questions/275018/how-can-i-remove-a-trailing-newline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "',MICROSOFT CORP,VISIONARY\\nNFLX'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "microsoft_string = microsoft_string.strip()\n",
    "microsoft_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "while we can perform lots of operations on strings, # kind of difficult to do any sort of analysis in the given state.\n",
    "if we think about this in excel terms, it's like having all your data in a single cell...\n",
    "what need to do is split all the values into multiple cells\n",
    "luckily, string types have a split() method that splits a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[',MICROSOFT', 'CORP,VISIONARY', 'NFLX']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "microsoft_string.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so, if we don't put anything in as input to the .string() method, it'll split on spaces\n",
    "but, if we add a \\n character as input value (surrounded by quotes)\n",
    "we are able to split the string into a list of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['', 'MICROSOFT CORP', 'VISIONARY\\nNFLX']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "microsoft_string.split(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can save the output of the split to a new variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "microsoft_list = microsoft_string.split(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can slice into lists, just like we can slice into strings\n",
    "note:  unlike excel which starts with row (or index) 1, python starts with index 0\n",
    "since we can see the first element in list is header, we can use 0 to index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "ticker = microsoft_list[0]\n",
    "print(ticker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we could get the first company in the list\n",
    "by using index 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MICROSOFT CORP\n"
     ]
    }
   ],
   "source": [
    "name = microsoft_list[1]\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "sponsor_level = microsoft_list[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "another way we can use the open method is by using with open()\n",
    "i'd say it's the preferred method for opening files in Python\n",
    "by using the \"with open() as f\", don't have to remember to close the file when done\n",
    "will automatically close file\n",
    "\n",
    "Note the second line is indented, this is another must know concept:\n",
    "In Python, Indented code blocks are always preceded by a colon (:) on the previous line\n",
    "the amount of whitespace following the colon (:) is up to the user, but it's widely accepted\n",
    "in the python community (Python Style Guide) to use 4 spaces when indenting\n",
    "If you use an IDE, you can use tab and it will automatically space to 4 characters\n",
    "Also, if you are wanting to run the following lines (or any lines with colon (:), you need to select the line with the colon and the indented lines below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sponsor_level,amount\n",
      "VISIONARY,150000\n",
      "SUSTAINABILITY,90000\n",
      "MAINTAINING,60000\n",
      "CONTRIBUTING,30000\n",
      "SUPPORTING,15000\n",
      "PARTNER,7500\n",
      "PARTICIPATING,3750\n",
      "ASSOCIATE,1500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(pycon_sponsor_levels_filepath) as f:\n",
    "    pycon_sponsor_levels_data = f.read()\n",
    "\n",
    "print(pycon_sponsor_levels_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sponsor_level,amount\\nVISIONARY,150000\\nSUSTAINABILITY,90000\\nMAINTAINING,60000\\nCONTRIBUTING,30000\\nSUPPORTING,15000\\nPARTNER,7500\\nPARTICIPATING,3750\\nASSOCIATE,1500\\n'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycon_sponsor_levels_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if we just run pycon_sponsor_levels_data without print(), we can actually see there are these \\n values in the data\n",
    "\n",
    "some resources explaining what is happening with raw strings\n",
    "\n",
    "https://knowledge.kitchen/Raw_strings_in_Python\n",
    "\n",
    "https://realpython.com/python-print/\n",
    "\n",
    "https://www.codevscolor.com/python-raw-string\n",
    "\n",
    "https://stackoverflow.com/questions/2081640/what-exactly-do-u-and-r-string-flags-do-and-what-are-raw-string-literals\n",
    "\n",
    "again, we can think of the current state of our data as being in a single excel cell... we need to get our data into a data structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sponsor_level,amount', 'VISIONARY,150000', 'SUSTAINABILITY,90000', 'MAINTAINING,60000', 'CONTRIBUTING,30000', 'SUPPORTING,15000', 'PARTNER,7500', 'PARTICIPATING,3750', 'ASSOCIATE,1500', '']\n"
     ]
    }
   ],
   "source": [
    "pycon_sponsor_levels_list = pycon_sponsor_levels_data.split(\"\\n\")\n",
    "print(pycon_sponsor_levels_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "like strings, we can index & slice lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sponsor_level,amount\n"
     ]
    }
   ],
   "source": [
    "item = pycon_sponsor_levels_list[0]\n",
    "print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if we could figure out way to access each item in a list\n",
    "we could split each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sponsor_level', 'amount']"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "item.split(\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can use a for-loop to access each item in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sponsor_level,amount\n",
      "VISIONARY,150000\n",
      "SUSTAINABILITY,90000\n",
      "MAINTAINING,60000\n",
      "CONTRIBUTING,30000\n",
      "SUPPORTING,15000\n",
      "PARTNER,7500\n",
      "PARTICIPATING,3750\n",
      "ASSOCIATE,1500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for item in pycon_sponsor_levels_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sponsor_level', 'amount']\n",
      "['VISIONARY', '150000']\n",
      "['SUSTAINABILITY', '90000']\n",
      "['MAINTAINING', '60000']\n",
      "['CONTRIBUTING', '30000']\n",
      "['SUPPORTING', '15000']\n",
      "['PARTNER', '7500']\n",
      "['PARTICIPATING', '3750']\n",
      "['ASSOCIATE', '1500']\n",
      "['']\n"
     ]
    }
   ],
   "source": [
    "for item in pycon_sponsor_levels_list:\n",
    "    print(item.split(\",\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we could store the split values in a list\n",
    "we need to create an empty list first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "items = []\n",
    "\n",
    "for item in pycon_sponsor_levels_list:\n",
    "    # we use append method to add new items to a list\n",
    "    split_item = item.split(\",\")\n",
    "    items.append(split_item)\n",
    "\n",
    "# we know have a list of lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['sponsor_level', 'amount'], ['VISIONARY', '150000'], ['SUSTAINABILITY', '90000'], ['MAINTAINING', '60000'], ['CONTRIBUTING', '30000'], ['SUPPORTING', '15000'], ['PARTNER', '7500'], ['PARTICIPATING', '3750'], ['ASSOCIATE', '1500'], ['']]\n"
     ]
    }
   ],
   "source": [
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IF Statements & Booleans\n",
    "\n",
    "https://www.w3schools.com/python/python_conditions.asp\n",
    "\n",
    "Just like Excel, Python has Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python actually has a library for reading CSV files\n",
    "\n",
    "https://docs.python.org/3/library/csv.html\n",
    "\n",
    "https://realpython.com/python-csv/\n",
    "\n",
    "to use a library in the Standard Library (think Excel Add-ins), we use the import statement then the name of the library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we are going to store the values into a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pycon_sponsor_levels = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "remember, if see a colon (:) need to indent four spaces for everything below\n",
    "also, if you run to run the following code snippet,\n",
    "you need to select all the indented lines below the with statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row Number:\t 0 \n",
      "Row Values:\t ['VISIONARY', '150000']\n",
      "Row Number:\t 1 \n",
      "Row Values:\t ['SUSTAINABILITY', '90000']\n",
      "Row Number:\t 2 \n",
      "Row Values:\t ['MAINTAINING', '60000']\n",
      "Row Number:\t 3 \n",
      "Row Values:\t ['CONTRIBUTING', '30000']\n",
      "Row Number:\t 4 \n",
      "Row Values:\t ['SUPPORTING', '15000']\n",
      "Row Number:\t 5 \n",
      "Row Values:\t ['PARTNER', '7500']\n",
      "Row Number:\t 6 \n",
      "Row Values:\t ['PARTICIPATING', '3750']\n",
      "Row Number:\t 7 \n",
      "Row Values:\t ['ASSOCIATE', '1500']\n"
     ]
    }
   ],
   "source": [
    "with open(pycon_sponsor_levels_filepath, 'r') as f:\n",
    "\n",
    "    rows = csv.reader(f)\n",
    "\n",
    "    # skip header row\n",
    "    header = next(f)\n",
    "\n",
    "    # we can use the enumerate built-in function to add index number\n",
    "    # remember, if see a colon (:) need to indent four spaces for everything below\n",
    "    for row_number, row in enumerate(rows):\n",
    "        print(\"Row Number:\\t\", row_number,\"\\nRow Values:\\t\", row)\n",
    "\n",
    "        sponsor_level = row[0]\n",
    "        # can use int built-in function to convert string to integer\n",
    "        amount = int(row[1])\n",
    "\n",
    "        # create a dictionary for each company\n",
    "        sponsor_level_dict = {\n",
    "            \"sponsor_level\": sponsor_level,\n",
    "            \"amount\": amount\n",
    "        }\n",
    "\n",
    "        pycon_sponsor_levels.append(sponsor_level_dict)\n",
    "# you would select down to this row if wanted to run code in repl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'sponsor_level': 'VISIONARY', 'amount': 150000}, {'sponsor_level': 'SUSTAINABILITY', 'amount': 90000}, {'sponsor_level': 'MAINTAINING', 'amount': 60000}, {'sponsor_level': 'CONTRIBUTING', 'amount': 30000}, {'sponsor_level': 'SUPPORTING', 'amount': 15000}, {'sponsor_level': 'PARTNER', 'amount': 7500}, {'sponsor_level': 'PARTICIPATING', 'amount': 3750}, {'sponsor_level': 'ASSOCIATE', 'amount': 1500}]\n"
     ]
    }
   ],
   "source": [
    "print(pycon_sponsor_levels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "pretty print makes printing data pretty\n",
    "part of the standard library, so comes installed with python\n",
    "we need to import pprint in order to use it\n",
    "https://docs.python.org/3/library/pprint.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'amount': 150000, 'sponsor_level': 'VISIONARY'},\n",
      " {'amount': 90000, 'sponsor_level': 'SUSTAINABILITY'},\n",
      " {'amount': 60000, 'sponsor_level': 'MAINTAINING'},\n",
      " {'amount': 30000, 'sponsor_level': 'CONTRIBUTING'},\n",
      " {'amount': 15000, 'sponsor_level': 'SUPPORTING'},\n",
      " {'amount': 7500, 'sponsor_level': 'PARTNER'},\n",
      " {'amount': 3750, 'sponsor_level': 'PARTICIPATING'},\n",
      " {'amount': 1500, 'sponsor_level': 'ASSOCIATE'}]\n"
     ]
    }
   ],
   "source": [
    "pprint.pprint(pycon_sponsor_levels)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can use the from to import just the pprint function\n",
    "this way we don't have to do pprint.pprint(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'amount': 150000, 'sponsor_level': 'VISIONARY'},\n",
      " {'amount': 90000, 'sponsor_level': 'SUSTAINABILITY'},\n",
      " {'amount': 60000, 'sponsor_level': 'MAINTAINING'},\n",
      " {'amount': 30000, 'sponsor_level': 'CONTRIBUTING'},\n",
      " {'amount': 15000, 'sponsor_level': 'SUPPORTING'},\n",
      " {'amount': 7500, 'sponsor_level': 'PARTNER'},\n",
      " {'amount': 3750, 'sponsor_level': 'PARTICIPATING'},\n",
      " {'amount': 1500, 'sponsor_level': 'ASSOCIATE'}]\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "\n",
    "pprint(pycon_sponsor_levels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pycon_sponsor_levels)\n",
    "# list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "since a list, we can use indexing & slicing to access elements in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'sponsor_level': 'VISIONARY', 'amount': 150000}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sponsor_level = pycon_sponsor_levels[0]\n",
    "\n",
    "print(sponsor_level)\n",
    "type(sponsor_level)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Dictionary\n",
    "\n",
    "What type of operations/methods can we perform on a dictionary?\n",
    "https://www.w3schools.com/python/python_ref_dictionary.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "since this is a dictionary data type, it's got keys, values, and items\n",
    "\n",
    "we can print the dictionary keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['sponsor_level', 'amount'])\n"
     ]
    }
   ],
   "source": [
    "print(sponsor_level.keys())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can see the values by using the values \"method\" on a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['VISIONARY', 150000])\n"
     ]
    }
   ],
   "source": [
    "print(sponsor_level.values())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can see both keys and values using the items \"method\" on a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('sponsor_level', 'VISIONARY'), ('amount', 150000)])\n"
     ]
    }
   ],
   "source": [
    "print(sponsor_level.items())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can use the keys to access dictionary values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VISIONARY\n"
     ]
    }
   ],
   "source": [
    "print(sponsor_level['sponsor_level'])\n",
    "# VISIONARY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150000\n"
     ]
    }
   ],
   "source": [
    "print(sponsor_level['amount'])\n",
    "# 150000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'amount': 150000, 'sponsor_level': 'VISIONARY'}\n"
     ]
    }
   ],
   "source": [
    "sponsor_level_name = \"VISIONARY\"\n",
    "amount = 150000\n",
    "\n",
    "sponsor_level = {\"sponsor_level\": sponsor_level_name, \"amount\": amount}\n",
    "\n",
    "pprint(sponsor_level)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'amount': 150000, 'sponsor_level': 'VISIONARY'}\n"
     ]
    }
   ],
   "source": [
    "sponsor_level = {}\n",
    "\n",
    "sponsor_level[\"sponsor_level\"] = \"VISIONARY\"\n",
    "sponsor_level[\"amount\"] = 150000\n",
    "\n",
    "pprint(sponsor_level)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "When you find yourself copying and pasting code, it might be an sign that you should use a function,.\n",
    "\n",
    "https://www.w3schools.com/python/python_functions.asp\n",
    "\n",
    "recall that print() is a built-in function\n",
    "\n",
    "(below) we say \"hello\" is the argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "say we wanted to create a sum function similar to excel\n",
    "=sum(A1, A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def excel_sum(A1, A2):\n",
    "    sum = A1 + A2\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "A1 = 1\n",
    "A2 = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "excel_sum(A1, A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "excel_sum(A1, A2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Date time\n",
    "\n",
    "Tip For Excel Users:  Learn to go from string to datetime and back\n",
    "\n",
    "https://docs.python.org/3/library/datetime.html\n",
    "\n",
    "tutorial https://realpython.com/python-datetime/\n",
    "\n",
    "examples https://pymotw.com/3/datetime/\n",
    "\n",
    "examples https://www.w3schools.com/python/python_datetime.asp\n",
    "\n",
    "more examples: https://www.programiz.com/python-programming/datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "date_now = datetime.datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(date_now)\n",
    "# Out[188]: datetime.datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-11 19:38:39.936704\n",
      "May\n"
     ]
    }
   ],
   "source": [
    "dir(date_now)\n",
    "\n",
    "print(date_now)\n",
    "# 2021-05-11 14:17:07.393726\n",
    "\n",
    "x = datetime.datetime(2021, 5, 12)\n",
    "\n",
    "print(x.strftime(\"%B\"))"
   ]
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}