examples/Examples-SGF2019-HOW-Everything_Is_Better_With_Friends.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Everything is better with friends: Executing SAS code in Python scripts with SASPy\n",
    "\n",
    "## Hands-on Workshop &nbsp;&bullet;&nbsp;  SAS Global Forum (SGF) 2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 0. [Python] Get version number (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "import platform\n",
    "print(platform.sys.version)\n",
    "```\n",
    "Notes:\n",
    "1. Assuming a Python 3 kernel is associated with this Notebook, the Python version and operating-system information should be printed. \n",
    "2. To increase performance, only a small number of modules in Python's standard library are loaded by default, so the `platform` module is explicitly loaded.\n",
    "3. Three examples of how Python syntax differs from SAS:\n",
    "  * We don't need semicolons at the end of each statement. Unlike SAS, semicolons are optional in Python, and they are typically only used to separate multiple statements placed on the same line (e.g., this example could be written on one line as follows: `import platform; print(platform.sys.version)`).\n",
    "  * The code `IMPORT PLATFORM` would produce an error. Unlike SAS, capitalization matters in Python.\n",
    "  * The `platform` object module invokes the sub-module object `sys` nested inside of it, and `sys` invokes the object `version` nested inside of it. Unlike SAS, dot-notation has a consistent meaning in Python and can be used to reference objects nested inside each other at any depth. (Think Russian nesting dolls or turduckens.)\n",
    "4. If an error is displayed, an incompatibility kernel has been chosen. This Notebook was developed using the Python 3.5 kernel provided with SAS University Edition as of February 2019."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1. [Python] Display available modules (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "help('modules')\n",
    "```\n",
    "Notes:\n",
    "1. All Python modules available to the Notebook's kernel should be printed, including\n",
    "  * standard library modules (e.g., `platform`, which was used above),\n",
    "  * and any third-party modules that have been installed (e.g., `pandas` and `saspy`, which will be used below).\n",
    "2. Python has a large standard library because of its \"batteries included\" philosophy. In addition, numerous third-party modules are actively developed and made freely available through sites like <https://github.com/> and <https://pypi.org/>.\n",
    "3. Another example of how Python syntax differs from SAS:\n",
    "  * `help(\"modules\")` would produce identical output. Unlike SAS, single and double quotes always have identical behavior in Python.\n",
    "4. The modules `pandas` and `saspy` will need to appear for the remaining examples in this Notebook to work, and `saspy` will need to be pre-configured to connect to a SAS kernel with access to the `sashelp` library. Depending on the versions of the modules installed, warnings or errors might also appear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2. [Python] Define a `str` object (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "hello_world_str = 'Hello, Jupyter!'\n",
    "print(hello_world_str)\n",
    "print()\n",
    "if hello_world_str == 'Hello, Jupyter!':\n",
    "    print(type(hello_world_str))\n",
    "else:\n",
    "    print(\"The string doesn't have the expected value!\")\n",
    "```\n",
    "Notes:\n",
    "1. A string (`str` for short) object named `hello_world_str` is created, and the following are printed with a blank line between them:\n",
    "  * the value of the string\n",
    "  * its type\n",
    "2. Three more examples of how Python syntax differs from SAS:\n",
    "  * `hello_world_str` can be assigned a value virtually anywhere, and it could be reassigned a value later with a completely different type (e.g., `hello_world_str = 42` would change `type(hello_world_str) = int`). Unlike SAS, variables are dynamically typed in Python.\n",
    "  * The code `if hello_world_str = 'Hello, Jupyter!'` would produce an error. Unlike SAS, single-equals (=) only ever means assignment, and double-equals (==) only ever tests for equality in Python.\n",
    "  * Removing indentation would also produce errors. Unlike SAS, indentation is significant and used to determine scope in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 3. [Python] Define a `list` object (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "hello_world_list = ['Hello', 'list']\n",
    "print(hello_world_list)\n",
    "print()\n",
    "print(type(hello_world_list))\n",
    "```\n",
    "Notes:\n",
    "1. A list object named `hello_world_list` with two values is created, and the following are printed with a blank line between them:\n",
    "  * the value of the list\n",
    "  * its type\n",
    "2. Lists are the most fundamental Python data structure and are related to SAS data-step arrays. Values in lists are always kept in insertion order, meaning the order they appear in the list's definition, and they can be individually accessed using numerical indexes within bracket notation:\n",
    "  * `hello_world_list[0]` returns `'Hello'`\n",
    "  * `hello_world_list[1]` returns `'list'`\n",
    "3. Another example of how Python syntax differs from SAS:\n",
    "  * The left-most element of a list is always at index 0. Unlike SAS, customized indexing is only available for more sophisticated data structures in Python (e.g., a dictionary; as in the next example)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 4. [Python] Define a `dict` object (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "hello_world_dict = {\n",
    "        'salutation'      : ['Hello'       , 'dict'],\n",
    "        'valediction'     : ['Goodbye'     , 'list'],\n",
    "        'part of speech'  : ['interjection', 'noun'],\n",
    "}\n",
    "print(hello_world_dict)\n",
    "print()\n",
    "print(type(hello_world_dict))\n",
    "```\n",
    "Notes:\n",
    "1. A dictionary (`dict` for short) object named `hello_world_dict` with three key-value pairs is created, and the following are printed with a blank line between them:\n",
    "  * the value of the dictionary\n",
    "  * its type\n",
    "2. Dictionaries are another fundamental Python data structure and are related to SAS formats and data-step hash tables. Dictionaries are more generally called _associative arrays_ or _maps_ because they map keys (appearing before the colons) to values (appearing after the colons). In other words, the value associated with each key can be accessed using bracket notation:\n",
    "  * `hello_world_dict['salutation']` returns `['Hello', 'dict']`\n",
    "  * `hello_world_dict['valediction']` returns `['Goodbye', 'list']`\n",
    "  * `hello_world_dict['part of speech']` returns `['interjection', 'noun']`\n",
    "3. In Python 3.5, the print order of key-value pairs may not match insertion order, meaning the order key-value pairs are listed when the dictionary is created. As of Python 3.7 (released in June 2018), insertion order is preserved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 5. [Python w/ `pandas`] Define a `DataFrame` object (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "from pandas import DataFrame\n",
    "hello_world_df = DataFrame(\n",
    "    {\n",
    "        'salutation'      : ['Hello'      , 'DataFrame'],\n",
    "        'valediction'     : ['Goodbye'    , 'dict'],\n",
    "        'part of speech'  : ['exclamation', 'noun'],\n",
    "    }\n",
    ")\n",
    "print(hello_world_df)\n",
    "print()\n",
    "hello_world_df.info()\n",
    "```\n",
    "Notes:\n",
    "1. A DataFrame (`df` for short) object named `hello_world_df` with dimensions 2x3 (2 rows and 3 columns) is created, and the following are printed with a blank line between them:\n",
    "  * the value of the DataFrame\n",
    "  * some information about it, which is obtained by `hello_world_df` calling its `info` method (meaning a function whose definition is nested inside it)\n",
    "2. Since DataFrames are not built into Python, we must first import their definition from the `pandas` module. Like their R counterpart, DataFrames are two-dimensional arrays of values that can be thought of like SAS datasets. However, while SAS datasets are typically only accessed from disk and processed row-by-row, DataFrames are loaded into memory all at once. This means values in DataFrames can be randomly accessed, but it also means the size of DataFrames can't grow beyond available memory.\n",
    "3. The dimensions of the DataFrame are determined as follows:\n",
    "  * The keys `'salutation'`, `'valediction'`, and `'part of speech'` of the dictionary passed to the `DataFrame` constructor function become column labels.\n",
    "  * Because each key maps to a list of length two, each column will be two elements tall (with an error occurring if the lists are not of non-uniform length). \n",
    "4. This example gives one option for building a DataFrame, but the constructor function can also accept many other object types, including another DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 6. [Python w/ `saspy`] Connect to a SAS kernel (IL)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "from saspy import SASsession\n",
    "sas = SASsession()\n",
    "type(sas)\n",
    "```\n",
    "Notes:\n",
    "1. A SASsession object named `sas` is created, and the following are printed with a blank line between them:\n",
    "  * Confirmation a SAS session has been established\n",
    "  * The type of object `sas`\n",
    "2. As with the DataFrame object type above, SASsession is not built into Python, so we first need to import its definition from the `saspy` module.\n",
    "3. The code `from saspy import SASsession; sas = SASsession()` only needs to be used to establish a SAS kernel connection once within a given Python session. All subsequent cells in this Notebook will assume these lines have been executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 7. [Python w/ `pandas` & `saspy`] Load a SAS dataset into a `DataFrame` (IL)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "fish_df = sas.sasdata2dataframe(table='fish', libref='sashelp')\n",
    "print(type(fish_df))\n",
    "print()\n",
    "fish_df.describe()\n",
    "```\n",
    "Notes:\n",
    "1. A DataFrame object named `fish_df` with dimensions 159x7 (159 rows and 7 columns) is created from the SAS dataset `fish` in the `sashelp` library, and the following are printed with a blank line between them:\n",
    "  * The type of object `fish_df`\n",
    "  * summary information about its 6 numerical columns, which is obtained by `fish_df` calling its `describe` method (the pandas equivalent of the SAS MEANS procedure)\n",
    "2. The `sas` object represents a connection to a SAS session and was created when a previous cell was run. Here, `sas` calls its `sasdata2dataframe` method to access the SAS library `sashelp` defined within this SAS session and to load the entire contents of SAS dataset `sashelp.fish` into the DataFrame `fish_df`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 8. [Python w/ `pandas`] Manipulate a `DataFrame` (IL)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "fish_df_g   = fish_df.groupby('Species')\n",
    "fish_df_gs  = fish_df_g['Weight']\n",
    "fish_df_gsa = fish_df_gs.agg(['count', 'std', 'mean', 'min', 'max'])\n",
    "print(fish_df_gsa)\n",
    "```\n",
    "Notes:\n",
    "1. The DataFrame `fish_df`, which was created in a cell above from the SAS dataset `sashelp.fish`, is manipulated, and the following is printed:\n",
    "  * a table giving the number of rows, standard deviation, mean, min, and max of `Weight` in `fish_df` when aggregated by `Species` \n",
    "2. This is accomplished by creating a series of new DataFrames with each assignment:\n",
    "  * The DataFrame `fish_df_g` is created from `fish_df` using the `groupby` method to group rows by values in column `'Species'`.\n",
    "  * The DataFrame `fish_df_gs` is created from `fish_df_g` by extracting the `'Weight'` column using bracket notation.\n",
    "  * The DataFrame `fish_df_gsa` is created from `fish_df_gs` using the `agg` method to aggregate using the functions in the list `['count', 'std', 'mean', 'min', 'max']`.\n",
    "3. Identical results could be obtained using the following SAS code:\n",
    "```SAS\n",
    "proc means data=sashelp.fish std mean min max;\n",
    "        class species;\n",
    "        var Weight;\n",
    "run;\n",
    "```\n",
    "However, while PROC MEANS operates on SAS datasets row-by-row from disk, DataFrames are stored entirely in memory. Consequently, any number of DataFrame operations can be combined for on-the-fly reshaping. Using so-called \"method chaining\", `fish_df_gsa` could have instead been created as follows:\n",
    "```Python\n",
    "fish_df.groupby('Species')['Weight'].agg(['count', 'std', 'mean', 'min', 'max'])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 9. [Python w/ `pandas` & `saspy`] Load a `DataFrame` into a SAS dataset; execute SAS code (IL)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "from IPython.display import HTML\n",
    "sas.dataframe2sasdata(fish_df_gsa, table=\"fish_sds_gsa\", libref=\"Work\")\n",
    "sas_submit_return_value = sas.submit('PROC PRINT DATA=fish_sds_gsa; RUN;')\n",
    "sas_submit_results = sas_submit_return_value['LST']\n",
    "HTML(sas_submit_results)\n",
    "```\n",
    "Notes:\n",
    "1. The DataFrame `fish_df_gsa`, which was created in a cell above from the SAS dataset `sashelp.fish`, is used to create the new SAS dataset `Work.fish_sds_gsa`, the SAS PRINT procedure is called, and the following is printed:\n",
    "  * the fully rendered HTML table returned by PROC PRINT\n",
    "2. The `sas` object, which was created in a cell above, is a persistent connection to a SAS session, and two of its methods are used as follows:\n",
    "  * The `dataframe2sasdata` method is used to write the contents of the DataFrame `fish_df_gsa` to the SAS dataset `fish_sds_gsa` stored in the `Work` library. (Note: The row indexes of the DataFrame `fish_df_gsa` are lost when the SAS dataset `fish_sds_gsa` is created.)\n",
    "  * The `submit` method is used to submit the PROC PRINT step to the SAS kernel, and a dictionary is returned with the following two key-value pairs:\n",
    "    - `sas_submit_return_value['LST']` is a string comprising the HTML results from executing PROC PRINT\n",
    "    - `sas_submit_return_value['LOG']` is a string comprising the plain-text log resulting from executing PROC PRINT\n",
    "3. In order to render the HTML results returned by PROC PRINT, we first load the `HTML` function from the third-party Interactive Python (`IPython` for short) module, which is the Jupyter system is built upon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 10. [Python w/ `saspy`] Get information about a SAS session (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "sas_submit_return_value = sas.submit('PROC PRODUCT_STATUS; RUN;')\n",
    "sas_submit_log = sas_submit_return_value['LOG']\n",
    "print(sas_submit_log)\n",
    "```\n",
    "Notes:\n",
    "1. The SAS PRODUCT_STATUS procedure is called, and the following is printed:\n",
    "  * the log returned by PROC PRODUCT_STATUS\n",
    "2. The `sas` object, which was created in a cell above, is a persistent connection to a SAS session, and its `submit` method is used to submit the PROC PRODUCT_STATUS step to the SAS kernel. A dictionary is returned with the following two key-value pairs:\n",
    "    - `sas_submit_return_value['LST']` is a string comprising the HTML results from executing PROC PRODUCT_STATUS, which is empty because no output is produced by this procedure\n",
    "    - `sas_submit_return_value['LOG']` is a string comprising the plain-text log resulting from executing PROC PRODUCT_STATUS\n",
    "3. Since a plain-text value is being printed, Python's `print` function is used to render the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 11. [Python w/ `saspy`] Connect directly to a SAS dataset (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "fish_sds = sas.sasdata(table='fish', libref='sashelp')\n",
    "print(type(fish_sds))\n",
    "print()\n",
    "fish_sds.columnInfo()\n",
    "```\n",
    "Notes:\n",
    "1. The SASdata object `fish_sds` (meaning a direct connection to the disk-based SAS dataset `sashelp.fish`, not an in-memory DataFrame) is created, and the following are printed with a blank line between them:\n",
    "  * The type of object `fish_sds`\n",
    "  * Summary information about the 7 columns in SAS dataset\n",
    "2. The `sas` object, which was created in a cell above, is a persistent connection to a SAS session, and its `sasdata` method is used to create the connection to `sashelp.fish`.\n",
    "3. The `fish_sds` object calls its _convenience method_ `columnInfo`, which implicitly invokes PROC CONTENTS on `sashelp.fish`. (Additional convenience methods can be found at <https://sassoftware.github.io/saspy/api.html#sas-data-object>.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 12. [Python w/ `saspy`] Get SAS code generated by a convenience method (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "sas.teach_me_SAS(True)\n",
    "fish_sds.means()\n",
    "sas.teach_me_SAS(False)\n",
    "```\n",
    "Notes:\n",
    "1. The SASdata object `fish_sds`, which was created in a cell above as a direct connection to the SAS dataset `sashelp.fish`, calls its _convenience method_ `means` within a \"Teach Me SAS\" sandwich, and the following is printed:\n",
    "  * The SAS code for the PROC MEANS step implicitly generated by the `means` convenience method\n",
    "2. The `sas` object, which was created in a cell above, is a persistent connection to a SAS session, and its `teach_me_SAS` method is used as follows:\n",
    "  * When called with argument `True`, SAS output is suppressed for all subsequent `saspy` convenience methods, and the SAS code generated is returned instead.\n",
    "  * When `teach_me_SAS` is called with argument `False`, this behavior is turned off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extra Credit. [Python w/ `saspy` and Jupyter magic command] Execute arbitrary SAS code (MS)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```\n",
    "%%SAS sas\n",
    "proc means data=sashelp.fish std mean min max;\n",
    "    class species;\n",
    "    var Weight;\n",
    "run;\n",
    "```\n",
    "Notes:\n",
    "1. The Jupyter magic command `%%SAS` is used to redirect all code in the cell to the SAS kernel associated with SASsession object `sas` created when a previous cell was run.\n",
    "2. Magic commands like `%%SAS` allow code in different languages to be intermixed within the same Notebook and are particularly helpful when options aren't provided by SASPy convenience methods (like the `class` statement for PROC MEANS). However, if both SAS and Python code should be intermixed within the same cell of a Notebook connected to a Python kernel, the `sas.submit` method will need to be used to submit SAS code to a SAS kernel.\n",
    "3. The magic command `%lsmagic` can be used to list all magic commands available within a Notebook session, including both built-in commands and commands made available when packages are loaded. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extra Credit. [Python w/ `saspy`] Imitate the SAS Macro Processor (IL)\n",
    "\n",
    "Type the following code into the cell labelled `[ ]:` immediately below, and then run that cell using Shift-Enter:\n",
    "```Python\n",
    "from IPython.display import HTML\n",
    "sas_code_fragment = 'proc means data=sashelp.%s; run;'\n",
    "for dsn in ['fish','iris']:\n",
    "    display(HTML(sas.submit(sas_code_fragment%dsn)['LST']))\n",
    "```\n",
    "Notes:\n",
    "1. A string object named `sas_code_fragment` is created with templating placeholder `%s`, which will be filled using other strings in subsequent uses of `sas_code_fragment`.\n",
    "2. The output of PROC MEANS applied to SAS datasets `sashelp.fish` and `sashelp.iris` is then displayed by extracting the results output from SAS session code submissions and rendering their HTML.\n",
    "3. The `sas` object represents a connection to a SAS session and was created when a previous cell was run. Here, `sas` calls its `submit` method for each value of the for-loop indexing variable `dsn`, and the `%s` portion of `sas_code_fragment` is replaced by the value of `dsn`. In other words, the following SAS code is submitted to the SAS kernel:\n",
    "```\n",
    "proc means data=sashelp.fish; run; \n",
    "proc means data=sashelp.iris; run; \n",
    "```\n",
    "4. The same outcome could also be achieved with the following SAS macro code:\n",
    "```\n",
    "%macro loop(); \n",
    "        %let dsn_list = fish iris;\n",
    "        %do i = 1 %to 2; \n",
    "            %let dsn = %scan(&dsn_list.,&i.);\n",
    "            proc means data=sashelp.&dsn.;\n",
    "            run; \n",
    "        %end;\n",
    "%mend; \n",
    "%loop()\n",
    "```\n",
    "However, note the following differences:\n",
    "  * Python allows us to concisely repeat an arbitrary block of code by iterating over a list using a for-loop. In other words, the body of the for-loop (meaning everything indented underneath it, since Python uses indentation to determine scope) is repeated for each string in the list `['fish','iris']`.\n",
    "  * The SAS macro facility only provides do-loops based on index variables (the macro variable `i` above), so clever tricks like implicitly defined arrays (macro variable `dsn_list` above) need to be used together with functions like `%scan` to extract a sequence of values."
   ]
  },
  {
   "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}