@misc{absolute_path,
	IDS    = {},
	title  = {absolute path},
	author = {},
	note   = {The series of folders, starting at the \ul{root} \ul{directory} (folder), that must be traversed to locate a specific directory or file on a computer. },
	}
 
@misc{alias,
	IDS    = {},
	title  = {alias},
	author = {},
	note   = {A new name for an \ul{object} that already has a name. Often used when importing Python \ul{libraries}, where it can be used to provide a shorter name for an already named object. e.g., \lstinline{import numpy as np}.  In this example, \lstinline{np} is the alias. },
	}
 
@misc{analytical,
	IDS    = {},
	title  = {analytical},
	author = {},
	note   = {In the context of \ul{models}, this means that there is a solution that can be written down as a mathematical equation. This is in contrast to those solutions requiring \ul{numerical} approaches.},
	}
 
@misc{arbitrary_keyword_argument,
	IDS    = {},
	title  = {"arbitrary keyword "},
	author = {},
	note   = {In a \ul{function}, this is similar to a \ul{keyword} argument, but the function allows you to \ul{pass} an arbitrary number of them.  Usually, the keyword/value pairs are packed up in a \ul{dictionary}.  Typically these are referred to as \lstinline{**kwargs} in function definitions.},
	}
 
@misc{arbitrary_positional_argument,
	IDS    = {},
	title  = {arbitrary positional argument},
	author = {},
	note   = {In a \ul{function}, this is similar to a \ul{positional argument}, but the function allows you to \ul{pass} an arbitrary number of them.  Typically these are referred to as \lstinline{*args} in function definitions.},
	}
 
@misc{argument,
	IDS    = {},
	title  = {argument},
	author = {},
	note   = {\ul{Data} that is \ul{pass}ed to a \ul{function} when it is \ul{call}ed. The data is either \ul{operate}d on, or it specifies the manner in which the function should operate. In Python, there are four types of arguments: \ul{positional arguments},  \ul{keyword arguments},  \ul{arbitrary positional arguments}, and  \ul{arbitrary keyword arguments.}  Data passed as an argument in a function call is assigned to the corresponding \ul{parameter} specified in the function definition.},
	}
 
@misc{assign,
	IDS    = {},
	title  = {assign},
	author = {},
	note   = {The operation of associating an \ul{object} with a \ul{variable} name. },
	}
 
@misc{attribute,
	IDS    = {},
	title  = {attribute},
	author = {},
	note   = {Data associated with an \ul{object}.  The value of the attribute can be accessed by naming the object, using a period, and then stating the name of the attribute desired. e.g., <object>.<attribute>},
	}
 
@misc{base64_encoding,
	IDS    = {},
	title  = {base 64 encoding},
	author = {},
	note   = {A form of \ul{binary encoding} that is based on 64 bits, or 2^6 possible values. },
	}
 
@misc{binary_encoding,
	IDS    = {},
	title  = {binary encoding},
	author = {},
	note   = {A form of storing data that is not intended for humans to read.  This differs from \ul{plain text} data storage, often used when you intend humans to read the data.  Binary encoded data typically uses less space than plain text to represent the same data.},
	}
 
@misc{binary_format,
	IDS    = {},
	title  = {binary format},
	author = {},
	note   = {The details of how data is translated when using \ul{binary encoding}.},
	}
 
@misc{bitmap,
	IDS    = {},
	title  = {bitmap},
	author = {},
	note   = {One approach to encoding image data. In a bitmap, the image is stored by breaking it into a grid of pixels, and then assigning colors to each of these pixels. },
	}
 
@misc{block,
	IDS    = {},
	title  = {block},
	author = {},
	note   = {A portion of Python code that shares the same indentation level.  Often used to indicate that the code all belongs to the same \ul{control structure}},
	}
 
@misc{boolean,
	IDS    = {},
	title  = {boolean},
	author = {},
	note   = {A \ul{data type} that has only two possible values: \lstinline{True} and \lstinline{False}.},
	}
 
@misc{broadcast,
	IDS    = {broadcasting},
	title  = {broadcast},
	author = {broadcasting},
	note   = {The ability of Numpy to expand a smaller \ul{Numpy array} so that it has the same shape as a larger Numpy array, allowing for element-wise operations without explicitly duplicating values.},
	}
 
@misc{call,
	IDS    = {},
	title  = {call},
	author = {},
	note   = {Invoking some code from some other code.  For instance, if one utilizes a \u{function}, we say we have `called' the function, or that we invoked a function call. },
	}
 
@misc{class,
	IDS    = {},
	title  = {class},
	author = {},
	note   = {A collection of Python code that defines a complex, self-contained \ul{object} composed of data, \ul{methods} that transform the data, and \ul{attributes} that provide information about the data.  A class can be thought of a template: it does not hold data, but has instructions on how to create an \ul{instance} of the class that will hold data. },
	}
 
@misc{codechembook,
	IDS    = {},
	title  = {codechembook},
	author = {},
	note   = {Python \ul{library} written by the authors of this book to accomplish tasks common to experimental chemists. },
	}
 
@misc{collection,
	IDS    = {},
	title  = {collection},
	author = {},
	note   = {An \ul{object} that contains multiple other \ul{object}s but that can be referred to with a single \ul{variable} name.},
	}
 
@misc{comment,
	IDS    = {},
	title  = {comment},
	author = {},
	note   = {A portion of code that is not meant to be \ul{executed}, but is used to \ul{document} the code. Comments are used to improve the \u{readability} and understandability of code. },
	}
 
@misc{complex,
	IDS    = {},
	title  = {complex},
	author = {},
	note   = {A numerical \ul{data type} used to represent complex numbers. },
	}
 
@misc{concatenate,
	IDS    = {concatenation},
	title  = {concatenate},
	author = {concatenation},
	note   = {Join two \ul{collections} together.},
	}
 
@misc{conditional_statement,
	IDS    = {},
	title  = {conditional expression},
	author = {},
	note   = {Code that is executed if, and only if, a condition associated with returns a value of \listinline{True}.},
	}
 
@misc{console,
	IDS    = {},
	title  = {console},
	author = {},
	note   = {Also sometimes called the \ul{command line}. An interface by which a user can enter text-based commands that the computer will execute. This is done in an interactive manner, so that each command is executed as it is entered. },
	}
 
@misc{constructor,
	IDS    = {},
	title  = {constructor},
	author = {},
	note   = {A \ul{method} to create an \ul{instance} of a \ul{class}.},
	}
 
@misc{control_structure,
	IDS    = {},
	title  = {control strucure},
	author = {},
	note   = {A \ul{statement} that allows code to execute in a defined order other than simply line by line.},
	}
 
@misc{creation,
	IDS    = {},
	title  = {creation},
	author = {},
	note   = {Making a new \ul{instance} of an \ul{object}. },
	}
 
@misc{data_stream,
	IDS    = {},
	title  = {data stream},
	author = {},
	note   = {A continuous flow of data that can be processed incrementally, rather than loading the entire data set into \ul{memory} at once, and then processing that. },
	}
 
@misc{data_type,
	IDS    = {},
	title  = {data type},
	author = {},
	note   = {Classification of the values that \ul{objects} can hold. For instance, Python makes a distinction between text (\u{strings}) and numbers. Within number, Python makes a distinction between numbers with decimal places (\ul{floats}) and numbers without decimal places (\ul{int}s). },
	}
 
@misc{delimited,
	IDS    = {},
	title  = {delimited},
	author = {},
	note   = {A format of human-readable data whereby different values are separated by a \ul{delimiter}. },
	}
 
@misc{delimiter,
	IDS    = {},
	title  = {delimiter},
	author = {},
	note   = {When data is \ul{delimited}, this is the character that is used to separate the values.  Often the delimiter is a particular characters of text, such as a comma, semicolon, tab, or space. Often this strategy is used to create data files in \ul{plain text}.},
	}
 
@misc{dictionary,
	IDS    = {dictionaries},
	title  = {dictionary},
	author = {dictionaries},
	note   = {A collection of \ul{values} in which each value is paired with a \ul{key} that serves as a mnemonic label that identifies it and makes it easy to access programmatically.},
	}
 
@misc{directory,
	IDS    = {directories},
	title  = {directory},
	author = {directories},
	note   = {A location on a computer where files can be stored. },
	}
 
@misc{docstring,
	IDS    = {Docstring},
	title  = {docstring},
	author = {Docstring},
	note   = {A multiline \ul{comment} that directly follows the definition line for a \ul{function}.  This typically gives information regarding the function’s purpose, the \ul{parameter}s/\ul{argument}s for the function, and what the function \ul{returns}. Some \ul{IDE}s will use these docstrings to dynamically provide information on the function, when you include it in your code. },
	}
 
@misc{document,
	IDS    = {},
	title  = {document},
	author = {},
	note   = {The process of providing a guide for understanding and using code.  This can be done by using \ul{comment}s and \ul{docstring}s, but one can also point to online resources, or other means of documentation. },
	}
 
@misc{e_notation,
	IDS    = {},
	title  = {e notation},
	author = {},
	note   = {A notation used to represent numbers with decimal places.  It is similar to scientific notation, but $10^X$ is replaced by \lstinline{e}$X$. Thus, the \lstinline{e} is a placeholder for “ten to the power of. },
	}
 
@misc{error,
	IDS    = {},
	title  = {error},
	author = {},
	note   = {The result of Python attempting to execute instructions that can not correctly complete. The error can happen for many different reasons, such as incorrect \ul{syntax} or missing values. },
	}
 
@misc{error_handling,
	IDS    = {},
	title  = {error handling},
	author = {},
	note   = {Writing code to recover from \ul{error}s, rather than stopping execution of the program.  Good practice, especially when common errors can be anticipated—such as errors in a user specifying a file \ul{path}.},
	}
 
@misc{exclusive,
	IDS    = {},
	title  = {exclusive},
	author = {},
	note   = {Does not include the specified \ul{object}. Often used when discussing \ul{indexing}—especially when \ul{slicing}. In such a case, a range of indices are given and the final index in the specified range is excluded. The opposite of \ul{inclusive}.},
	}
 
@misc{executable_instructions,
	IDS    = {},
	title  = {executable instructions},
	author = {},
	note   = {Code that include valid commands/\ul{expressions}. },
	}
 
@misc{expression,
	IDS    = {},
	title  = {expression},
	author = {},
	note   = {A line of code that evaluates to a \ul{value}.},
	}
 
@misc{extension,
	IDS    = {},
	title  = {extension},
	author = {},
	note   = {Part of a filename, often hidden by an operating system, that follows a period.  It is used to specify the type of data in a file and is used by a computer to know what programs can open the file.  For instance, Microsoft Word files often end in .docx. In this case `docx' is the extension, and it is what is used to tell the computer to open this file in Microsoft Word when you double click on it. },
	}
 
@misc{f_string,
	IDS    = {},
	title  = {f-string},
	author = {},
	note   = {A way to create \ul{string}s in Python in which the result obtained by evaluating an \ul{expression} can be included in the string.  This is done by placing an “f” before the string starts, and then adding the code to be executed between curly brackets (\{\}). },
	}
 
@misc{figure_object,
	IDS    = {},
	title  = {figure object},
	author = {},
	note   = {The \ul{object} that holds all data for a Plotly figure. },
	}
 
@misc{file_structure,
	IDS    = {},
	title  = {file structure},
	author = {},
	note   = {The arrangement of files and \ul{directories} in a computer’s \ul{file system}.},
	}
 
@misc{file_system,
	IDS    = {},
	title  = {file system},
	author = {},
	note   = {A framework for defining the relationships of \ul{directories} and files on a computer.  \ul{File structures} are implemented within this framework.},
	}
 
@misc{float,
	IDS    = {},
	title  = {float},
	author = {},
	note   = {The name of the \ul{data type} for working with numbers with decimals within Python. },
	}
 
@misc{footer,
	IDS    = {},
	title  = {footer},
	author = {},
	note   = {In a .csv file, text that appears on lines after the data rows.},
	}
 
@unpublished{for,
	IDS    = {},
	title  = {for},
	author = {},
	note   = {A \ul{keyword} that indicates that there will be \ul{iteration} through the elements in a \ul{collection}. },
	}
 
@misc{function,
	IDS    = {},
	title  = {function},
	author = {},
	note   = {A reusable \ul{block} of code that performs a specific task and can be \ul{call}ed by its name. Functions can accept inputs (called \ul{parameters}), execute \ul{statements}, and \ul{return} results to the code that calls it.},
	}
 
@misc{generator,
	IDS    = {},
	title  = {generator},
	author = {},
	note   = {An \ul{object} that holds instructions for creating data, rather than the data itself. },
	}
 
@misc{glyph,
	IDS    = {},
	title  = {glyph},
	author = {},
	note   = {The visual representation of characters in written language. All the different forms of representing the ampersand, for instance, are all different glyphs. },
	}
 
@misc{hard_coding,
	IDS    = {},
	title  = {hard coding},
	author = {},
	note   = {When values are specified directly in the code, rather than being obtained from somewhere else (i.e., an external file, or user input).},
	}
 
@misc{header,
	IDS    = {},
	title  = {header},
	author = {},
	note   = {In a .csv file, text that appears on lines before the data rows.  It is often used to provide important information about the data and/or to label columns to give the user information about the organization of the data.},
	}
 
@misc{hexadecimal,
	IDS    = {},
	title  = {hexadecimal},
	author = {},
	note   = {A way to represent a base-16 number system. Binary can be represented using 1 and 0.  Base 10 uses 0, 1, 2, 3, 4, 5, 6, 7, 8,  and 9.  Base 16 uses these same digits, but adds: a, b, c, d, e, and f. },
	}
 
@misc{histogram,
	IDS    = {},
	title  = {histogram},
	author = {},
	note   = {A representation of data in which data is divided into bins with lower and upper limits and the counts or frequency of the data falling between these limits is drawn using bars in a chart. },
	}
 
@misc{HTML,
	IDS    = {},
	title  = {HTML},
	author = {},
	note   = {Stands for hypertext markup language, which is a means to specify how text, images, and other data can be represented on a screen.  This is used widely for webpages. },
	}
 
@misc{IDE,
	IDS    = {},
	title  = {Integrated Development Environment (IDE)},
	author = {},
	note   = {A computer program that assists a programmer in creating code.  Typically it includes a text editor with syntax highlighting, a \ul{console}, and tools to aid debugging.},
	}
 
@misc{immutability,
	IDS    = {},
	title  = {immutability},
	author = {},
	note   = {A property of certain \ul{data types} that, once created, their value cannot be altered. },
	}
 
@misc{import,
	IDS    = {},
	title  = {import},
	author = {},
	note   = {The means by which to add functionality to Python. Once a \ul{class}, \ul{module}, or \ul{function} is imported, you can use it in your code. },
	}
 
@unpublished{in,
	IDS    = {},
	title  = {in},
	author = {},
	note   = {The \ul{keyword} for an \ul{operator} that \ul{evaluates} to a \ul{boolean} depending on whether an \ul{object} exists within a \ul{collection}.},
	}
 
@misc{in_place,
	IDS    = {},
	title  = {in place},
	author = {},
	note   = {A behavior in which the values within an \ul{object} are changed without re-naming the object or \ul{assign}ing it to a different \ul{variable} name. },
	}
 
@misc{inclusive,
	IDS    = {},
	title  = {inclusive},
	author = {},
	note   = {Includes the specified \ul{object}.  Often used when discussing \ul{indexing}—especially when \ul{slicing}. In such a case, a range of indices are given and the first index in the specified range is included. The opposite of \ul{exclusive}.},
	}
 
@misc{index,
	IDS    = {indices},
	title  = {index},
	author = {indices},
	note   = {An \ul{integer} that specifies the position of an element within an \ul{slice}able \ul{collection}.  The first position has, by definition, the index 0.},
	}
 
@misc{inner_array,
	IDS    = {},
	title  = {inner array},
	author = {},
	note   = {When the elements of a \ul{Numpy array} are also arrays, the contained (or nested) arrays are called ‘inner arrays.’ The containing array is called an ‘\ul{outer array}.’},
	}
 
@misc{instance,
	IDS    = {},
	title  = {instance},
	author = {},
	note   = {A specific \ul{object} holding data that has been created from a \ul{class}.},
	}
 
@misc{instantiation,
	IDS    = {},
	title  = {instantiation},
	author = {},
	note   = {The \ul{creation} of an \ul{instance} of an object. },
	}
 
@unpublished{int,
	IDS    = {},
	title  = {int},
	author = {},
	note   = {The name of the \ul{data type} for working with \ul{integers} within Python. },
	}
 
@misc{iterable,
	IDS    = {},
	title  = {iterable},
	author = {},
	note   = {A property of an \ul{collection} whereby the elements can be processed one by one.  For ordered collections, the elements are processed in order. },
	}
 
@misc{iterate,
	IDS    = {},
	title  = {iterate},
	author = {},
	note   = {Execute a \ul{block} of code a single time in a \ul{loop}.  The \ul{iteration} number is advanced each time a loop iterates.},
	}
 
@misc{iterating,
	IDS    = {},
	title  = {iterating},
	author = {},
	note   = {The process of \ul{iteration}. },
	}
 
@misc{iteration,
	IDS    = {},
	title  = {iteration},
	author = {},
	note   = {A given round of \ul{execution} of a code \ul{block} in a \ul{loop}.  Often a specific iteration is identified using \ul{integer}s. So, one speaks of `the 4th iteration', for instance, or 'iteration number 4.},
	}
 
@misc{key,
	IDS    = {},
	title  = {key},
	author = {},
	note   = {Together with a \ul{value}, this forms a key/value pair for a \ul{dictionary}.  One can access the value by referencing the key.},
	}
 
@misc{keyword,
	IDS    = {},
	title  = {keyword},
	author = {},
	note   = {Word used in a \ul{statement} or \ul{expression} with special meaning that causes an action. Examples in Python include \lstinline{import}, \lstinline{for}, and \lstinline{in}. Keywords can not be used as \ul{variable} names.  Alternately, keyword refers to the name of a \ul{keyword argument} in a \ul{function}.},
	}
 
@misc{keyword_argument,
	IDS    = {},
	title  = {keyword argument},
	author = {},
	note   = {\ul{Arguments} passed to functions that are not required for the function to be \ul{call}ed.  They must appear after \ul{positional arguments}, but their order does not matter. Data is \ul{pass}ed to a keyword argument by assigning the data to the corresponding keyword in an assignment statement within the function call.  Here, the use of ``keyword is distinct from reserved \ul{keyword}s above.},
	}
 
@misc{library,
	IDS    = {libraries},
	title  = {library},
	author = {libraries},
	note   = {A external set of Python files that define new \ul{class}es, \ul{function}s, etc. that can be \ul{import}ed to add new capability to code. },
	}
 
@misc{list,
	IDS    = {},
	title  = {list},
	author = {},
	note   = {A \ul{slicable}, \ul{mutable} \ul{collection} \ul{data type} that can hold any type of \ul{object}.},
	}
 
@misc{list_comprehension,
	IDS    = {},
	title  = {list comprehension},
	author = {},
	note   = {},
	}
 
@misc{literal,
	IDS    = {},
	title  = {literal},
	author = {},
	note   = {A fixed value that is directly written into the code to represent data. Sometimes this is called ‘hard coding.’ This approach stands in contrast to the use of \ul{variable}s. },
	}
 
@misc{lmfit,
	IDS    = {},
	title  = {lmfit},
	author = {},
	note   = {A Python \ul{library} that functions as a \ul{wrapper} for many behaviors of another library: Scipy.  This library is often used to fit the \ul{return} of \ul{functions} to data. },
	}
 
@misc{loop,
	IDS    = {},
	title  = {loop},
	author = {},
	note   = {A series of instructions that are repeated.},
	}
 
@misc{memory,
	IDS    = {},
	title  = {memory},
	author = {},
	note   = {Hardware in a computer that can temporarily store data.  \ul{Variable}s identify the location of specific data in memory.},
	}
 
@misc{method,
	IDS    = {},
	title  = {method},
	author = {},
	note   = {A \ul{function} that is contained in an \ul{object} and that acts on that object.  Thus, one must \ul{call} the function by first listing the object: <object>.method().},
	}
 
@misc{model,
	IDS    = {},
	title  = {model},
	author = {},
	note   = {A parameterized quantitative mathematical prediction of the response of a phenomenon to an independent quantity. For example, a linear equation ($y = m{\cdot}x  + b$) is a model of linear behavior. },
	}
 
@misc{module,
	IDS    = {},
	title  = {module},
	author = {},
	note   = {A Python file (i.e., a file ending in .py) that is typically part of a Python \ul{library}.},
	}
 
@misc{mutability,
	IDS    = {},
	title  = {mutability},
	author = {},
	note   = {A property of certain \ul{data types} that, once created, their value can be altered. This can lead to unexpected behavior when multiple \ul{variable} names point to the same mutable \ul{object}.},
	}
 
@misc{nesting,
	IDS    = {},
	title  = {nesting},
	author = {},
	note   = {The process of containing one \ul{collection} of \ul{object}s in another collection of objects. },
	}
 
@misc{newline_character,
	IDS    = {},
	title  = {newline character},
	author = {},
	note   = {A text symbol that is often not rendered. Instead, it is used to mark where a line should end, and a new line begin.  This is the behavior that is expected from the “Enter” or “Return” key on your keyboard. In Python, this is specified by the \ul{string}: {\textbackslash}n},
	}
 
@misc{numerical,
	IDS    = {},
	title  = {numerical},
	author = {},
	note   = {In the context of \ul{models}, this means that there is not solution that can be written down as a single mathematical equation. Instead, all functions involved in the solution are approximated by a series of numerical values.  This is in contrast to solutions that can be solved with \ul{analytical} approaches.},
	}
 
@misc{numerical_precision,
	IDS    = {},
	title  = {numerical precision},
	author = {},
	note   = {The idea that not all numbers can be represented exactly in a computer. This is due to the fact that there are an infinite amount of numbers, but only a finite amount of computer \ul{memory}.},
	}
 
@misc{Numpy,
	IDS    = {Numpy_library},
	title  = {Numpy},
	author = {Numpy_library},
	note   = {A \ul{library} that provides classes and functions for working with \ul{Numpy array}s. },
	}
 
@misc{Numpy_array,
	IDS    = {},
	title  = {Numpy array},
	author = {},
	note   = {An ordered, \ul{sliceable} collection of values.  All values must be of the same \ul{data type}.  Numpy arrays allow for \ul{vectorization} and \ul{broadcasting}.},
	}
 
@misc{object,
	IDS    = {},
	title  = {object},
	author = {},
	note   = {An \ul{instance} of a \ul{class}.  This means that the object will have specific data, \ul{attributes}, and \ul{methods}.},
	}
 
@misc{object_oriented,
	IDS    = {},
	title  = {object oriented},
	author = {},
	note   = {A programming approach by which common data transformations and queries are built into the \ul{objects} themselves (as \ul{methods} and \ul{attributes}, respectively), rather than separately programmed.  Thus, solutions to problems become a sequence of requests for the objects to change themselves, rather than a sequence of original code to change their values.  This allows the programmer to focus on the solution more than the specific implementation of algorithms.},
	}
 
@misc{operated,
	IDS    = {},
	title  = {operated},
	author = {},
	note   = {Indicates that at least one \ul{object} has had the action of an \ul{operator} applied to it.},
	}
 
@misc{operator,
	IDS    = {},
	title  = {operator},
	author = {},
	note   = {A \ul{keyword} or reserved symbol in code that instructs the computer to perform a specific action on one or more \ul{objects}.  Examples include mathematical operations (+, -, *, / **) or assignment to \ul{variables} (=). },
	}
 
@misc{outer_array,
	IDS    = {},
	title  = {outer array},
	author = {},
	note   = {When an \ul{array} has multiple dimensions, this is represented by \ul{nesting} arrays. An array that contains arrays is an outer array, while the arrays inside that array are called \ul{inner arrays}.},
	}
 
@misc{parameter,
	IDS    = {},
	title  = {parameter},
	author = {},
	note   = {In a \ul{function} definition, a name of a \ul{variable} that exists only in the function that takes on the value of data passed as an \ul{argument} in the function \ul{call}.},
	}
 
@misc{parsing,
	IDS    = {},
	title  = {parsing},
	author = {},
	note   = {The act of processing a collection to identify and extract a subset of its data. For instance, pulling words from a sentence can be called ‘parsing’ the sentence. },
	}
 
@misc{pass,
	IDS    = {},
	title  = {pass},
	author = {},
	note   = {The act of transferring data from the code that \ul{call}s a \ul{function} to the code that specifies the behavior of the function. The data is passed using \ul{argument}s defined by the function.},
	}
 
@misc{path,
	IDS    = {Path},
	title  = {path},
	author = {Path},
	note   = {The text-based representation of a location in a computers file structure. Paths can be \ul{absolute} or \ul{relative}.},
	}
 
@misc{Pathlib,
	IDS    = {},
	title  = {Pathlib},
	author = {},
	note   = {A \ul{library} that provides \ul{class}es that represent \ul{path}s and \ul{method}s for manipulating them.},
	}
 
@misc{plain_text,
	IDS    = {},
	title  = {plain text},
	author = {},
	note   = {A representation of data that is readable by humans.  Plain text files can be opened and read in text editors.},
	}
 
@misc{Plotly,
	IDS    = {},
	title  = {Plotly},
	author = {},
	note   = {A \ul{library} used to create visualizations of data. },
	}
 
@misc{positional_argument,
	IDS    = {},
	title  = {positional argument},
	author = {},
	note   = {\ul{Arguments} that are required to be passed to \ul{function}s and which must be included in a function \ul{call} in the order specified by the function definition. This is different from \ul{ keyword arguments}. },
	}
 
@misc{Python_interpreter,
	IDS    = {},
	title  = {Python interpreter},
	author = {},
	note   = {The program that accepts Python code and executes the instructions contained in that code. },
	}
 
@misc{Pythonic,
	IDS    = {},
	title  = {Pythonic},
	author = {},
	note   = {Describes code that adheres to the stylistic conventions of the Python language. Typically refers to code that strives for simplicity and readability.},
	}
 
@misc{Pythonpath,
	IDS    = {PythonPATH},
	title  = {Pythonpath},
	author = {PythonPATH},
	note   = {A list of locations in the computer’s \ul{file structure} in which Python will attempt to find files associated with libraries to \ul{import}. },
	}
 
@misc{refactoring,
	IDS    = {},
	title  = {refactoring},
	author = {refactor},
	note   = {The process of breaking a \ul{script} down into a series of \ul{function}s that group the code into logical tasks.  Refactoring code makes it easier to reuse parts of it for other solutions.},
	}
 
@misc{relative_path,
	IDS    = {},
	title  = {relative path},
	author = {},
	note   = {The address to a specific \ul{directory} or file on a computer, relative to another \ul{directory} or file. },
	}
 
@misc{result_object,
	IDS    = {},
	title  = {result object},
	author = {},
	note   = {The \ul{object} that is \ul{return}ed from the fitting operation performed in \ul{lmfit}.},
	}
 
@misc{return,
	IDS    = {},
	title  = {return},
	author = {},
	note   = {A \ul{keyword} that instructs Python to end execution of a \ul{function} and \ul{pass} zero or more values back to the place in the code that it was called from.  In other words, it is the result of the evaluation of a function \ul{call}.},
	}
 
@misc{root,
	IDS    = {},
	title  = {root},
	author = {},
	note   = {The lowest level \ul{directory} in the file system.  All other directories and files are contained in this directory and its various levels of subdirectories.  The root directory is not contained in any other folder.},
	}
 
@misc{scalable_vector_graphic,
	IDS    = {},
	title  = {scalable vector graphic},
	author = {},
	note   = {A method to represent graphics using equations and other instructions that can be interpreted when the graphic is visualized, as opposed to specifying the graphic in terms of the appearance of each pixel in an array of pixels (the later is used in \ul{bitmaps}. Because information is not specified by pixel, the graphic is easily resized without losing resolution, and in some cases can result in dramatically smaller image files. },
	}
 
@misc{script,
	IDS    = {},
	title  = {script},
	author = {},
	note   = {A \ul{plain text} file that contains Python code that can be executed using the \ul{Python interpretor.}},
	}
 
@misc{shape,
	IDS    = {},
	title  = {shape},
	author = {},
	note   = {A \ul{tuple} containing the same number of elements as the dimensions of a \ul{nest}ed \ul{Numpy array}.  Each element of the tuple specifies the number of elements held by each array layer, working from the outermost array inward.},
	}
 
@misc{shell,
	IDS    = {},
	title  = {shell},
	author = {},
	note   = {A specific session of a \ul{Python interpreter} in a \ul{console}.},
	}
 
@misc{slicable,
	IDS    = {},
	title  = {slicable},
	author = {},
	note   = {A property of an \ul{object} that indicates that it can be \ul{indexed}.},
	}
 
@misc{slice,
	IDS    = {},
	title  = {slice},
	author = {},
	note   = {A subgroup of items selected from a \ul{iterable} collection . This subgroup is specified using \ul{indices}.},
	}
 
@misc{SMILES,
	IDS    = {},
	title  = {SMILES},
	author = {},
	note   = {A text-based representation of the structure of molecules and complexes.  SMILES stands for Simplified Molecular Input Line Entry System.},
	}
 
@misc{statement,
	IDS    = {},
	title  = {statement},
	author = {},
	note   = {A command that either \ul{assign}s a \ul{value} to a \ul{variable} or changes the execution order of the code.},
	}
 
@misc{string,
	IDS    = {},
	title  = {string},
	author = {},
	note   = {Technical name for the text \textbf{data type}.},
	}
 
@misc{syntax,
	IDS    = {},
	title  = {syntax},
	author = {},
	note   = {The rules that govern how computer code needs to be structured. Different languages define different syntax.},
	}
 
@misc{syntax_highlighting,
	IDS    = {},
	title  = {syntax highlighting},
	author = {},
	note   = {A feature of many text editors and \ul{IDEs} that formats the different elements of code using different font properties. For instance, one might use different colors for numbers, \ul{function}s, \ul{comments}, and \ul{strings}. },
	}
 
@misc{traceback,
	IDS    = {},
	title  = {traceback},
	author = {},
	note   = {Textual output generated in the console upon an \ul{error} in code execution.  The text attempts to give a record of what code was executed leading up to the error and a terse description of why the error occurred. },
	}
 
@misc{tuple,
	IDS    = {},
	title  = {tuple},
	author = {},
	note   = {A \ul{data type} that is a \ul{collection} that can hold other \ul{objects}.  Similar to a \ul{list}, but a tuple is \ul{immutable}.},
	}
 
@misc{unicode,
	IDS    = {},
	title  = {unicode},
	author = {},
	note   = {One common \ul{binary encoding} framework that allows code to specifies characters to be displayed when rendering text.  This allows you to display emojis.},
	}
 
@misc{unordered,
	IDS    = {},
	title  = {unordered},
	author = {},
	note   = {A property of a \ul{collection} which means that if it is \ul{iterated} through, the order of iteration is not guaranteed to be the same each time. },
	}
 
@misc{unpacked,
	IDS    = {unpacking},
	title  = {unpacked},
	author = {unpacking},
	note   = {The behavior by which the elements within a \ul{collection} are assigned to a number of \ul{variable}s equal to the number of elements in the collection. },
	}
 
@misc{uri_binary_stream,
	IDS    = {},
	title  = {uri binary stream},
	author = {},
	note   = {A \ul{data stream} that is encoded using Uniform Resource Identifier (URI).},
	}
 
@misc{value,
	IDS    = {},
	title  = {value},
	author = {},
	note   = {An \ul{object} stored in a \ul{dictionary}.  Values can be accessed using the associated \ul{key}.},
	}
 
@misc{variable,
	IDS    = {},
	title  = {variable},
	author = {},
	note   = {An \ul{object} with a user-defined name that identifies the location in \ul{memory} that holds data.  Variables allow the data to be referenced or manipulated throughout a program using the name. },
	}
 
@misc{vector_graphic,
	IDS    = {},
	title  = {vector graphic},
	author = {},
	note   = {A specification of images, whereby the instructions to draw the image is contained in equations specifying where to draw what color. },
	}
 
@misc{vectorization,
	IDS    = {},
	title  = {vectorization},
	author = {},
	note   = {A behavior of \ul{Numpy array}s whereby an \ul{operator} applied to the array is applied to each item in the collection automatically. },
	}
 
@misc{vectorized,
	IDS    = {},
	title  = {vectorized},
	author = {},
	note   = {A property of an instruction that specifies that the calculation should be performed using \ul{vectorization}.},
	}
 
@misc{version_control,
	IDS    = {},
	title  = {version control},
	author = {},
	note   = {The practice of organizing different copies of the same basic code in a way that makes it easy to identify the changes from one to another.  Good version control practices make it easy to identify which copy of a code is the one that behaves the way you want.},
	}
 
@misc{white_space,
	IDS    = {},
	title  = {white space},
	author = {},
	note   = {Tab, space, \ul{newline}, or any character which does not have a visual representation in text.  In Python, white space is used to designate which lines of code belong to a common code \ul{block}, for instance.},
	}
 
@misc{wildcard,
	IDS    = {},
	title  = {wildcard},
	author = {},
	note   = {When matching patterns in strings, a wildcard can be used to specify that any combination of characters will be considered a match. Typically denoted by an asterisk (*).},
	}
 
@misc{working_directory,
	IDS    = {},
	title  = {working directory},
	author = {},
	note   = {The \ul{directory} in which the Python interpreter is currently running.  This directory is included in the \ul{PythonPATH}  Files in the working directory can be accessed by Python without specifying their \ul{path}s.},
	}
 
@misc{wrapper,
	IDS    = {},
	title  = {wrapper},
	author = {},
	note   = {A \ul{function} that serves as an interface for another function to make it easier to use or to extend its capabilities.},
	}
 
@misc{mask,
	IDS    = {masking},
	title  = {mask},
	author = {masking},
	note   = {A \ul{Numpy array} of True or False values that can be used to select elements from another array. It must have the same \ul{shape} as the array it is applied to.},
	}
 
@misc{csv,
        title = {csv},
        author = {},
        note = {Stands for “comma separated variable.” Or sometimes the much more general  “character separated variable.” This is a format for structuring data in \ul{plain text} files.  A character (called a \ul{delimiter}) is chosen that is placed between pieces of data.  Then, one can simply separate out the values by breaking on this delimiter. This character is often a comma, but other ones are also used, such as tabs, spaces, colons, semicolons, etc. },
}

@misc{None,
        title = {None},
        author = {},
        note = {The only value allowed for the \texttt{NoneType} \ul{data type}. This is used by Python to indicate when there is no value. },
}

@misc{view,
        title = {view},
        author = {},
        note = {A way to access a only a subset of a \ul{Numpy array}. The view can be assigned to a new variable (which points to the elements of the original array), rather than making a copy of them to a new \ul{object}.  Thus, changes made to the view result in the same changes being made to the original array.},
}