Reference

Key Points

Running and Quitting	Python scripts are plain text files. Use the Jupyter Notebook for editing and running Python. The Notebook has Command and Edit modes. Use the keyboard and mouse to select and edit cells. The Notebook will turn Markdown into pretty-printed documentation. Markdown does most of what HTML does.
Variables and Assignment	Use variables to store values. Use `print` to display values. Variables persist between cells. Variables must be created before they are used. Variables can be used in calculations. Use an index to get a single character from a string. Use a slice to get a substring. Use the built-in function `len` to find the length of a string. Python is case-sensitive. Use meaningful variable names.
Data Types and Type Conversion	Every value has a type. Use the built-in function `type` to find the type of a value. Types control what operations can be done on values. Strings can be added and multiplied. Strings have a length (but numbers don’t). Must convert numbers to strings or vice versa when operating on them. Can mix integers and floats freely in operations. Variables only change value when something is assigned to them.
Built-in Functions and Help	Use comments to add documentation to programs. A function may take zero or more arguments. Commonly-used built-in functions include `max`, `min`, and `round`. Functions may only work for certain (combinations of) arguments. Functions may have default values for some arguments. Use the built-in function `help` to get help for a function. The Jupyter Notebook has two ways to get help. Every function returns something. Python reports a syntax error when it can’t understand the source of a program. Python reports a runtime error when something goes wrong while a program is executing. Fix syntax errors by reading the source code, and runtime errors by tracing the program’s execution.
Libraries	Most of the power of a programming language is in its libraries. A program must import a library module in order to use it. Use `help` to learn about the contents of a library module. Import specific items from a library to shorten programs. Create an alias for a library when importing it to shorten programs.
Reading Tabular Data into DataFrames	Use the Pandas library to get basic statistics out of tabular data. Use `index_col` to specify that a column’s values should be used as row headings. Use `DataFrame.info` to find out more about a dataframe. The `DataFrame.columns` variable stores information about the dataframe’s columns. Use `DataFrame.T` to transpose a dataframe. Use `DataFrame.describe` to get summary statistics about data.
Pandas DataFrames	Use `DataFrame.iloc[..., ...]` to select values by integer location. Use `:` on its own to mean all columns or all rows. Select multiple columns or rows using `DataFrame.loc` and a named slice. Result of slicing can be used in further operations. Use comparisons to select data based on value. Select values or NaN using a Boolean mask.
Plotting	`matplotlib` is the most widely used scientific plotting library in Python. Plot data directly from a Pandas dataframe. Select and transform data, then plot it. Many styles of plot are available: see the Python Graph Gallery for more options. Can plot many sets of data together.
Lists	A list stores many values in a single structure. Use an item’s index to fetch it from a list. Lists’ values can be replaced by assigning to them. Appending items to a list lengthens it. Use `del` to remove items from a list entirely. The empty list contains no values. Lists may contain values of different types. Character strings can be indexed like lists. Character strings are immutable. Indexing beyond the end of the collection is an error.
For Loops	A for loop executes commands once for each value in a collection. A `for` loop is made up of a collection, a loop variable, and a body. The first line of the `for` loop must end with a colon, and the body must be indented. Indentation is always meaningful in Python. Loop variables can be called anything (but it is strongly advised to have a meaningful name to the looping variable). The body of a loop can contain many statements. Use `range` to iterate over a sequence of numbers. The Accumulator pattern turns many values into one.
Conditionals	Use `if` statements to control whether or not a block of code is executed. Conditionals are often used inside loops. Use `else` to execute a block of code when an `if` condition is not true. Use `elif` to specify additional tests. Conditions are tested once, in order. Create a table showing variables’ values to trace a program’s execution.
Looping Over Data Sets	Use a `for` loop to process files given a list of their names. Use `glob.glob` to find sets of files whose names match a pattern. Use `glob` and `for` to process batches of files.
Writing Functions	Break programs down into functions to make them easier to understand. Define a function using `def` with a name, parameters, and a block of code. Defining a function does not run it. Arguments in a function call are matched to its defined parameters. Functions may return a result to their caller using `return`.
Variable Scope	The scope of a variable is the part of a program that can ‘see’ that variable.
Programming Style	Follow standard Python style in your code. Use docstrings to provide builtin help.
Wrap-Up	Python supports a large and diverse community across academia and industry.
Feedback	We are constantly seeking to improve this course.

Running and Quitting

Python files have the .py extension.
Can be written in a text file or a Jupyter Notebook.
- Jupyter notebooks have the extension .ipynb
- Jupyter notebooks can be opened from Anaconda or through the command line by entering $ jupyter notebook
  - Markdown and HTML are allowed in markdown cells for documenting code.

Variables and Assignment

Variables are stored using =.
- Strings are defined in quotations '...'.
- Integers and floating point numbers are defined without quotations.
Variables can contain letters, digits, and underscores _.
- Cannot start with a digit.
- Variables that start with underscores should be avoided.
Use print(...) to display values as text.
Can use indexing on strings.
- Indexing starts at 0.
- Position is given in square brackets [position] following the variable name.
- Take a slice using [start:stop]. This makes a copy of part of the original string.
  - start is the index of the first element.
  - stop is the index of the element after the last desired element.
Use len(...) to find the length of a variable or string.

Data Types and Type Conversion

Each value has a type. This controls what can be done with it.
- int represents an integer
- float represents a floating point number.
- str represents a string.
To determine a variables type, use the built-in function type(...), including the variable name in the parenthesis.
Modifying strings:
- Use + to concatenate strings.
- Use * to repeat a string.
- Numbers and strings cannot be added to on another.
  - Convert string to integer: int(...).
  - Convert integer to string: str(...).

Built-in Functions and Help

To add a comment, place # before the thing you do not with to be executed.
Commonly used built-in functions:
- min() finds the smallest value.
- max() finds the largest value.
- round() rounds off a floating point number.
- help() displays documentation for the function in the parenthesis.
  - Other ways to get help include holding down shift and pressing tab in Jupyter Notebooks.

Libraries

Importing a library:
- Use import ... to load a library.
- Refer to this library by using module_name.thing_name.
  - . indicates ‘part of’.
To import a specific item from a library: from ... import ...
To import a library using an alias: import ... as ...
Importing the math library: import math
- Example of referring to an item with the module’s name: math.cos(math.pi).
Importing the plotting library as an alias: import matplotlib as mpl

Reading Tabular Data into DataFrames

Use the pandas library to do statistics on tabular data. Load with import pandas as pd.
- To read in a csv: pd.read_csv(), including the path name in the parenthesis.
  - To specify a column’s values should be used as row headings: pd.read_csv('path', index_col='column name'), where path and column name should be replaced with the relevant values.
To get more information about a DataFrame, use DataFrame.info, replacing DataFrame with the variable name of your DataFrame.
Use DataFrame.columns to view the column names.
Use DataFrame.T to transpose a DataFrame.
Use DataFrame.describe to get summary statistics about your data.

Pandas DataFrames

Select data using [i,j]
- To select by entry position: DataFrame.iloc[..., ...]
  - This is inclusive of everything except the final index.
- To select by entry label: DataFrame.loc[..., ...]
  - Can select multiple rows or columns by listing labels.
  - This is inclusive to both ends.
- Use : to select all rows or columns.
Can also select data based on values using True and False. This is a Boolean mask.
- mask = subset > 10000
- We can then use this to select values.
To use a select-apply-combine operation we use data.apply(lambda x: x > x.mean()) where mean() can be any operation the user would like to be applied to x.

Plotting

The most widely used plotting library is matplotlib.
- Usually imported using import matplotlib.pyplot as plt.
- To plot we use the command plt.plot(time, position).
- To create a legend use plt.legend(['label1', 'label2'], loc='upper left')
  - Can also define labels within the plot statements by using plt.plot(time, position, label='label'). To make the legend show up, use plt.legend()
- To label x and y axis plt.xlabel('label') and plt.ylabel('label') are used.
Pandas DataFrames can be used to plot by using DataFrame.plot(). Any operations that can be used on a DataFrame can be applied while plotting.
- To plot a bar plot data.plot(kind='bar')

import matplotlib.puplot as plot
plt.plot(time, position, label='label')
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.legend()

Lists

Defined within [...] and separated by ,.
- An empty list can be created by using [].
Can use len(...) to determine how many values are in a list.
Can index just as done in previous lessons.
- Indexing can be used to reassign values list_name[0] = newvalue.
To add an item to a list use list_name.append(), with the item to append in the parenthesis.
To combine two lists use list_name_1.extend(list_name_2).
To remove an item from a list use del list_name[index].

For Loops

Start a for loop with for number in [1, 2, 3]:, with the following lines indented.
- [1, 2, 3] is considered the collection.
- number is the loop variable.
- The action following the collection is the body.
To iterate over a sequence of numbers use range(start, end)

for number in range(0,5):
    print(number)

Conditionals

Defined similarly to a loop, using if variable conditional value:.
- For example, if variable > 5:.
Use elif: for additional tests.
Use else: for when if statement is not true.
Can combine more than one conditional by using and or or.
Often used in combination with for loops.
Conditions that can be used:
- == equal to.
- >= greater than or equal to.
- <= less than or equal to.
- > greater than.
- < less than.

for m in [3, 6, 7, 2, 8]:
    if m > 5:
        print(m, 'is large')
    elif m == 5:
        print(m, 'is 5')
    else:
        print(m, 'is small')

Looping Over Data Sets

Use a for loop: for filename in [file1, file2]:
To find a set of files using a pattern use glob.glob
- Must import first using import glob.
- * indicates “match zero or more characters”
- ? indicates “match exactly one character”
  - For example: glob.glob(*.txt) will find all files that end with .txt in the current directory.
Combine these by writing a loop using: for filename in glob.glob(*.txt):

for filename in glob.glob(*.txt):
  data = pd.read_csv(filename)

Writing Functions

Define a function using def function_name(parameters):. Replace parameters with the variables to use when the function is executed.
Run by using function_name(parameters).
To return a result to the caller use return ... in the function.

def add_numbers(a, b):
    result = a + b
    return result

add_numbers(1, 4)

Variable Scope

A local variable is defined in a function and can only be seen and used within that function.
A global variable is defined outside of a function and can be seen or used anywhere after definition.

Programming Style

Document your code.
Use clear and meaningful variable names.
Follow the PEP8 style guide when setting up your code.
Use assertions to check for internal errors.
Use docstrings to provide help.

Glossary

Arguments: Values passed to functions.
Array: A container holding elements of the same type.
Boolean: An object composed of True and False.
DataFrame: The way Pandas represents a table; a collection of series.
Element: An item in a list or an array. For a string, these are the individual characters.
Function: A block of code that can be called and re-used elsewhere.
Global variable: A variable defined outside of a function that can be used anywhere.
Index: The position of a given element.
Jupyter Notebook: Interactive coding environment allowing a combination of code and markdown.
Library: A collection of files containing functions used by other programs.
Local Variable: A variable defined inside of a function that can only be used inside of that function.
Mask: A boolean object used for selecting data from another object.
Method: An action tied to a particular object. Called by using object.method.
Modules: The files within a library containing functions used by other programs.
Parameters: Variables used when executing a function.
Series: A Pandas data structure to represent a column.
Substring: A part of a string.
Variables: Names for values.

Plotting and Programming in Python: Reference

Key Points

Reference

Glossary